Merge pull request #32 from yokowu/main

feat: 模型供应商支持配置

backend/db/client.go

@@ -25,6 +25,8 @@ import (
 	"github.com/chaitin/MonkeyCode/backend/db/billingusage"
 	"github.com/chaitin/MonkeyCode/backend/db/invitecode"
 	"github.com/chaitin/MonkeyCode/backend/db/model"
+	"github.com/chaitin/MonkeyCode/backend/db/modelprovider"
+	"github.com/chaitin/MonkeyCode/backend/db/modelprovidermodel"
 	"github.com/chaitin/MonkeyCode/backend/db/setting"
 	"github.com/chaitin/MonkeyCode/backend/db/task"
 	"github.com/chaitin/MonkeyCode/backend/db/taskrecord"
@@ -58,6 +60,10 @@ type Client struct {
 	InviteCode *InviteCodeClient
 	// Model is the client for interacting with the Model builders.
 	Model *ModelClient
+	// ModelProvider is the client for interacting with the ModelProvider builders.
+	ModelProvider *ModelProviderClient
+	// ModelProviderModel is the client for interacting with the ModelProviderModel builders.
+	ModelProviderModel *ModelProviderModelClient
 	// Setting is the client for interacting with the Setting builders.
 	Setting *SettingClient
 	// Task is the client for interacting with the Task builders.
@@ -90,6 +96,8 @@ func (c *Client) init() {
 	c.BillingUsage = NewBillingUsageClient(c.config)
 	c.InviteCode = NewInviteCodeClient(c.config)
 	c.Model = NewModelClient(c.config)
+	c.ModelProvider = NewModelProviderClient(c.config)
+	c.ModelProviderModel = NewModelProviderModelClient(c.config)
 	c.Setting = NewSettingClient(c.config)
 	c.Task = NewTaskClient(c.config)
 	c.TaskRecord = NewTaskRecordClient(c.config)
@@ -186,23 +194,25 @@ func (c *Client) Tx(ctx context.Context) (*Tx, error) {
 	cfg := c.config
 	cfg.driver = tx
 	return &Tx{
-		ctx:               ctx,
-		config:            cfg,
-		Admin:             NewAdminClient(cfg),
-		AdminLoginHistory: NewAdminLoginHistoryClient(cfg),
-		ApiKey:            NewApiKeyClient(cfg),
-		BillingPlan:       NewBillingPlanClient(cfg),
-		BillingQuota:      NewBillingQuotaClient(cfg),
-		BillingRecord:     NewBillingRecordClient(cfg),
-		BillingUsage:      NewBillingUsageClient(cfg),
-		InviteCode:        NewInviteCodeClient(cfg),
-		Model:             NewModelClient(cfg),
-		Setting:           NewSettingClient(cfg),
-		Task:              NewTaskClient(cfg),
-		TaskRecord:        NewTaskRecordClient(cfg),
-		User:              NewUserClient(cfg),
-		UserIdentity:      NewUserIdentityClient(cfg),
-		UserLoginHistory:  NewUserLoginHistoryClient(cfg),
+		ctx:                ctx,
+		config:             cfg,
+		Admin:              NewAdminClient(cfg),
+		AdminLoginHistory:  NewAdminLoginHistoryClient(cfg),
+		ApiKey:             NewApiKeyClient(cfg),
+		BillingPlan:        NewBillingPlanClient(cfg),
+		BillingQuota:       NewBillingQuotaClient(cfg),
+		BillingRecord:      NewBillingRecordClient(cfg),
+		BillingUsage:       NewBillingUsageClient(cfg),
+		InviteCode:         NewInviteCodeClient(cfg),
+		Model:              NewModelClient(cfg),
+		ModelProvider:      NewModelProviderClient(cfg),
+		ModelProviderModel: NewModelProviderModelClient(cfg),
+		Setting:            NewSettingClient(cfg),
+		Task:               NewTaskClient(cfg),
+		TaskRecord:         NewTaskRecordClient(cfg),
+		User:               NewUserClient(cfg),
+		UserIdentity:       NewUserIdentityClient(cfg),
+		UserLoginHistory:   NewUserLoginHistoryClient(cfg),
 	}, nil
 }
 
@@ -220,23 +230,25 @@ func (c *Client) BeginTx(ctx context.Context, opts *sql.TxOptions) (*Tx, error)
 	cfg := c.config
 	cfg.driver = &txDriver{tx: tx, drv: c.driver}
 	return &Tx{
-		ctx:               ctx,
-		config:            cfg,
-		Admin:             NewAdminClient(cfg),
-		AdminLoginHistory: NewAdminLoginHistoryClient(cfg),
-		ApiKey:            NewApiKeyClient(cfg),
-		BillingPlan:       NewBillingPlanClient(cfg),
-		BillingQuota:      NewBillingQuotaClient(cfg),
-		BillingRecord:     NewBillingRecordClient(cfg),
-		BillingUsage:      NewBillingUsageClient(cfg),
-		InviteCode:        NewInviteCodeClient(cfg),
-		Model:             NewModelClient(cfg),
-		Setting:           NewSettingClient(cfg),
-		Task:              NewTaskClient(cfg),
-		TaskRecord:        NewTaskRecordClient(cfg),
-		User:              NewUserClient(cfg),
-		UserIdentity:      NewUserIdentityClient(cfg),
-		UserLoginHistory:  NewUserLoginHistoryClient(cfg),
+		ctx:                ctx,
+		config:             cfg,
+		Admin:              NewAdminClient(cfg),
+		AdminLoginHistory:  NewAdminLoginHistoryClient(cfg),
+		ApiKey:             NewApiKeyClient(cfg),
+		BillingPlan:        NewBillingPlanClient(cfg),
+		BillingQuota:       NewBillingQuotaClient(cfg),
+		BillingRecord:      NewBillingRecordClient(cfg),
+		BillingUsage:       NewBillingUsageClient(cfg),
+		InviteCode:         NewInviteCodeClient(cfg),
+		Model:              NewModelClient(cfg),
+		ModelProvider:      NewModelProviderClient(cfg),
+		ModelProviderModel: NewModelProviderModelClient(cfg),
+		Setting:            NewSettingClient(cfg),
+		Task:               NewTaskClient(cfg),
+		TaskRecord:         NewTaskRecordClient(cfg),
+		User:               NewUserClient(cfg),
+		UserIdentity:       NewUserIdentityClient(cfg),
+		UserLoginHistory:   NewUserLoginHistoryClient(cfg),
 	}, nil
 }
 
@@ -267,8 +279,9 @@ func (c *Client) Close() error {
 func (c *Client) Use(hooks ...Hook) {
 	for _, n := range []interface{ Use(...Hook) }{
 		c.Admin, c.AdminLoginHistory, c.ApiKey, c.BillingPlan, c.BillingQuota,
-		c.BillingRecord, c.BillingUsage, c.InviteCode, c.Model, c.Setting, c.Task,
-		c.TaskRecord, c.User, c.UserIdentity, c.UserLoginHistory,
+		c.BillingRecord, c.BillingUsage, c.InviteCode, c.Model, c.ModelProvider,
+		c.ModelProviderModel, c.Setting, c.Task, c.TaskRecord, c.User, c.UserIdentity,
+		c.UserLoginHistory,
 	} {
 		n.Use(hooks...)
 	}
@@ -279,8 +292,9 @@ func (c *Client) Use(hooks ...Hook) {
 func (c *Client) Intercept(interceptors ...Interceptor) {
 	for _, n := range []interface{ Intercept(...Interceptor) }{
 		c.Admin, c.AdminLoginHistory, c.ApiKey, c.BillingPlan, c.BillingQuota,
-		c.BillingRecord, c.BillingUsage, c.InviteCode, c.Model, c.Setting, c.Task,
-		c.TaskRecord, c.User, c.UserIdentity, c.UserLoginHistory,
+		c.BillingRecord, c.BillingUsage, c.InviteCode, c.Model, c.ModelProvider,
+		c.ModelProviderModel, c.Setting, c.Task, c.TaskRecord, c.User, c.UserIdentity,
+		c.UserLoginHistory,
 	} {
 		n.Intercept(interceptors...)
 	}
@@ -307,6 +321,10 @@ func (c *Client) Mutate(ctx context.Context, m Mutation) (Value, error) {
 		return c.InviteCode.mutate(ctx, m)
 	case *ModelMutation:
 		return c.Model.mutate(ctx, m)
+	case *ModelProviderMutation:
+		return c.ModelProvider.mutate(ctx, m)
+	case *ModelProviderModelMutation:
+		return c.ModelProviderModel.mutate(ctx, m)
 	case *SettingMutation:
 		return c.Setting.mutate(ctx, m)
 	case *TaskMutation:
@@ -1589,6 +1607,304 @@ func (c *ModelClient) mutate(ctx context.Context, m *ModelMutation) (Value, erro
 	}
 }
 
+// ModelProviderClient is a client for the ModelProvider schema.
+type ModelProviderClient struct {
+	config
+}
+
+// NewModelProviderClient returns a client for the ModelProvider from the given config.
+func NewModelProviderClient(c config) *ModelProviderClient {
+	return &ModelProviderClient{config: c}
+}
+
+// Use adds a list of mutation hooks to the hooks stack.
+// A call to `Use(f, g, h)` equals to `modelprovider.Hooks(f(g(h())))`.
+func (c *ModelProviderClient) Use(hooks ...Hook) {
+	c.hooks.ModelProvider = append(c.hooks.ModelProvider, hooks...)
+}
+
+// Intercept adds a list of query interceptors to the interceptors stack.
+// A call to `Intercept(f, g, h)` equals to `modelprovider.Intercept(f(g(h())))`.
+func (c *ModelProviderClient) Intercept(interceptors ...Interceptor) {
+	c.inters.ModelProvider = append(c.inters.ModelProvider, interceptors...)
+}
+
+// Create returns a builder for creating a ModelProvider entity.
+func (c *ModelProviderClient) Create() *ModelProviderCreate {
+	mutation := newModelProviderMutation(c.config, OpCreate)
+	return &ModelProviderCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
+}
+
+// CreateBulk returns a builder for creating a bulk of ModelProvider entities.
+func (c *ModelProviderClient) CreateBulk(builders ...*ModelProviderCreate) *ModelProviderCreateBulk {
+	return &ModelProviderCreateBulk{config: c.config, builders: builders}
+}
+
+// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates
+// a builder and applies setFunc on it.
+func (c *ModelProviderClient) MapCreateBulk(slice any, setFunc func(*ModelProviderCreate, int)) *ModelProviderCreateBulk {
+	rv := reflect.ValueOf(slice)
+	if rv.Kind() != reflect.Slice {
+		return &ModelProviderCreateBulk{err: fmt.Errorf("calling to ModelProviderClient.MapCreateBulk with wrong type %T, need slice", slice)}
+	}
+	builders := make([]*ModelProviderCreate, rv.Len())
+	for i := 0; i < rv.Len(); i++ {
+		builders[i] = c.Create()
+		setFunc(builders[i], i)
+	}
+	return &ModelProviderCreateBulk{config: c.config, builders: builders}
+}
+
+// Update returns an update builder for ModelProvider.
+func (c *ModelProviderClient) Update() *ModelProviderUpdate {
+	mutation := newModelProviderMutation(c.config, OpUpdate)
+	return &ModelProviderUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
+}
+
+// UpdateOne returns an update builder for the given entity.
+func (c *ModelProviderClient) UpdateOne(mp *ModelProvider) *ModelProviderUpdateOne {
+	mutation := newModelProviderMutation(c.config, OpUpdateOne, withModelProvider(mp))
+	return &ModelProviderUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
+}
+
+// UpdateOneID returns an update builder for the given id.
+func (c *ModelProviderClient) UpdateOneID(id string) *ModelProviderUpdateOne {
+	mutation := newModelProviderMutation(c.config, OpUpdateOne, withModelProviderID(id))
+	return &ModelProviderUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
+}
+
+// Delete returns a delete builder for ModelProvider.
+func (c *ModelProviderClient) Delete() *ModelProviderDelete {
+	mutation := newModelProviderMutation(c.config, OpDelete)
+	return &ModelProviderDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
+}
+
+// DeleteOne returns a builder for deleting the given entity.
+func (c *ModelProviderClient) DeleteOne(mp *ModelProvider) *ModelProviderDeleteOne {
+	return c.DeleteOneID(mp.ID)
+}
+
+// DeleteOneID returns a builder for deleting the given entity by its id.
+func (c *ModelProviderClient) DeleteOneID(id string) *ModelProviderDeleteOne {
+	builder := c.Delete().Where(modelprovider.ID(id))
+	builder.mutation.id = &id
+	builder.mutation.op = OpDeleteOne
+	return &ModelProviderDeleteOne{builder}
+}
+
+// Query returns a query builder for ModelProvider.
+func (c *ModelProviderClient) Query() *ModelProviderQuery {
+	return &ModelProviderQuery{
+		config: c.config,
+		ctx:    &QueryContext{Type: TypeModelProvider},
+		inters: c.Interceptors(),
+	}
+}
+
+// Get returns a ModelProvider entity by its id.
+func (c *ModelProviderClient) Get(ctx context.Context, id string) (*ModelProvider, error) {
+	return c.Query().Where(modelprovider.ID(id)).Only(ctx)
+}
+
+// GetX is like Get, but panics if an error occurs.
+func (c *ModelProviderClient) GetX(ctx context.Context, id string) *ModelProvider {
+	obj, err := c.Get(ctx, id)
+	if err != nil {
+		panic(err)
+	}
+	return obj
+}
+
+// QueryModels queries the models edge of a ModelProvider.
+func (c *ModelProviderClient) QueryModels(mp *ModelProvider) *ModelProviderModelQuery {
+	query := (&ModelProviderModelClient{config: c.config}).Query()
+	query.path = func(context.Context) (fromV *sql.Selector, _ error) {
+		id := mp.ID
+		step := sqlgraph.NewStep(
+			sqlgraph.From(modelprovider.Table, modelprovider.FieldID, id),
+			sqlgraph.To(modelprovidermodel.Table, modelprovidermodel.FieldID),
+			sqlgraph.Edge(sqlgraph.O2M, false, modelprovider.ModelsTable, modelprovider.ModelsColumn),
+		)
+		fromV = sqlgraph.Neighbors(mp.driver.Dialect(), step)
+		return fromV, nil
+	}
+	return query
+}
+
+// Hooks returns the client hooks.
+func (c *ModelProviderClient) Hooks() []Hook {
+	return c.hooks.ModelProvider
+}
+
+// Interceptors returns the client interceptors.
+func (c *ModelProviderClient) Interceptors() []Interceptor {
+	return c.inters.ModelProvider
+}
+
+func (c *ModelProviderClient) mutate(ctx context.Context, m *ModelProviderMutation) (Value, error) {
+	switch m.Op() {
+	case OpCreate:
+		return (&ModelProviderCreate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
+	case OpUpdate:
+		return (&ModelProviderUpdate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
+	case OpUpdateOne:
+		return (&ModelProviderUpdateOne{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
+	case OpDelete, OpDeleteOne:
+		return (&ModelProviderDelete{config: c.config, hooks: c.Hooks(), mutation: m}).Exec(ctx)
+	default:
+		return nil, fmt.Errorf("db: unknown ModelProvider mutation op: %q", m.Op())
+	}
+}
+
+// ModelProviderModelClient is a client for the ModelProviderModel schema.
+type ModelProviderModelClient struct {
+	config
+}
+
+// NewModelProviderModelClient returns a client for the ModelProviderModel from the given config.
+func NewModelProviderModelClient(c config) *ModelProviderModelClient {
+	return &ModelProviderModelClient{config: c}
+}
+
+// Use adds a list of mutation hooks to the hooks stack.
+// A call to `Use(f, g, h)` equals to `modelprovidermodel.Hooks(f(g(h())))`.
+func (c *ModelProviderModelClient) Use(hooks ...Hook) {
+	c.hooks.ModelProviderModel = append(c.hooks.ModelProviderModel, hooks...)
+}
+
+// Intercept adds a list of query interceptors to the interceptors stack.
+// A call to `Intercept(f, g, h)` equals to `modelprovidermodel.Intercept(f(g(h())))`.
+func (c *ModelProviderModelClient) Intercept(interceptors ...Interceptor) {
+	c.inters.ModelProviderModel = append(c.inters.ModelProviderModel, interceptors...)
+}
+
+// Create returns a builder for creating a ModelProviderModel entity.
+func (c *ModelProviderModelClient) Create() *ModelProviderModelCreate {
+	mutation := newModelProviderModelMutation(c.config, OpCreate)
+	return &ModelProviderModelCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
+}
+
+// CreateBulk returns a builder for creating a bulk of ModelProviderModel entities.
+func (c *ModelProviderModelClient) CreateBulk(builders ...*ModelProviderModelCreate) *ModelProviderModelCreateBulk {
+	return &ModelProviderModelCreateBulk{config: c.config, builders: builders}
+}
+
+// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates
+// a builder and applies setFunc on it.
+func (c *ModelProviderModelClient) MapCreateBulk(slice any, setFunc func(*ModelProviderModelCreate, int)) *ModelProviderModelCreateBulk {
+	rv := reflect.ValueOf(slice)
+	if rv.Kind() != reflect.Slice {
+		return &ModelProviderModelCreateBulk{err: fmt.Errorf("calling to ModelProviderModelClient.MapCreateBulk with wrong type %T, need slice", slice)}
+	}
+	builders := make([]*ModelProviderModelCreate, rv.Len())
+	for i := 0; i < rv.Len(); i++ {
+		builders[i] = c.Create()
+		setFunc(builders[i], i)
+	}
+	return &ModelProviderModelCreateBulk{config: c.config, builders: builders}
+}
+
+// Update returns an update builder for ModelProviderModel.
+func (c *ModelProviderModelClient) Update() *ModelProviderModelUpdate {
+	mutation := newModelProviderModelMutation(c.config, OpUpdate)
+	return &ModelProviderModelUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
+}
+
+// UpdateOne returns an update builder for the given entity.
+func (c *ModelProviderModelClient) UpdateOne(mpm *ModelProviderModel) *ModelProviderModelUpdateOne {
+	mutation := newModelProviderModelMutation(c.config, OpUpdateOne, withModelProviderModel(mpm))
+	return &ModelProviderModelUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
+}
+
+// UpdateOneID returns an update builder for the given id.
+func (c *ModelProviderModelClient) UpdateOneID(id uuid.UUID) *ModelProviderModelUpdateOne {
+	mutation := newModelProviderModelMutation(c.config, OpUpdateOne, withModelProviderModelID(id))
+	return &ModelProviderModelUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
+}
+
+// Delete returns a delete builder for ModelProviderModel.
+func (c *ModelProviderModelClient) Delete() *ModelProviderModelDelete {
+	mutation := newModelProviderModelMutation(c.config, OpDelete)
+	return &ModelProviderModelDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
+}
+
+// DeleteOne returns a builder for deleting the given entity.
+func (c *ModelProviderModelClient) DeleteOne(mpm *ModelProviderModel) *ModelProviderModelDeleteOne {
+	return c.DeleteOneID(mpm.ID)
+}
+
+// DeleteOneID returns a builder for deleting the given entity by its id.
+func (c *ModelProviderModelClient) DeleteOneID(id uuid.UUID) *ModelProviderModelDeleteOne {
+	builder := c.Delete().Where(modelprovidermodel.ID(id))
+	builder.mutation.id = &id
+	builder.mutation.op = OpDeleteOne
+	return &ModelProviderModelDeleteOne{builder}
+}
+
+// Query returns a query builder for ModelProviderModel.
+func (c *ModelProviderModelClient) Query() *ModelProviderModelQuery {
+	return &ModelProviderModelQuery{
+		config: c.config,
+		ctx:    &QueryContext{Type: TypeModelProviderModel},
+		inters: c.Interceptors(),
+	}
+}
+
+// Get returns a ModelProviderModel entity by its id.
+func (c *ModelProviderModelClient) Get(ctx context.Context, id uuid.UUID) (*ModelProviderModel, error) {
+	return c.Query().Where(modelprovidermodel.ID(id)).Only(ctx)
+}
+
+// GetX is like Get, but panics if an error occurs.
+func (c *ModelProviderModelClient) GetX(ctx context.Context, id uuid.UUID) *ModelProviderModel {
+	obj, err := c.Get(ctx, id)
+	if err != nil {
+		panic(err)
+	}
+	return obj
+}
+
+// QueryProvider queries the provider edge of a ModelProviderModel.
+func (c *ModelProviderModelClient) QueryProvider(mpm *ModelProviderModel) *ModelProviderQuery {
+	query := (&ModelProviderClient{config: c.config}).Query()
+	query.path = func(context.Context) (fromV *sql.Selector, _ error) {
+		id := mpm.ID
+		step := sqlgraph.NewStep(
+			sqlgraph.From(modelprovidermodel.Table, modelprovidermodel.FieldID, id),
+			sqlgraph.To(modelprovider.Table, modelprovider.FieldID),
+			sqlgraph.Edge(sqlgraph.M2O, true, modelprovidermodel.ProviderTable, modelprovidermodel.ProviderColumn),
+		)
+		fromV = sqlgraph.Neighbors(mpm.driver.Dialect(), step)
+		return fromV, nil
+	}
+	return query
+}
+
+// Hooks returns the client hooks.
+func (c *ModelProviderModelClient) Hooks() []Hook {
+	return c.hooks.ModelProviderModel
+}
+
+// Interceptors returns the client interceptors.
+func (c *ModelProviderModelClient) Interceptors() []Interceptor {
+	return c.inters.ModelProviderModel
+}
+
+func (c *ModelProviderModelClient) mutate(ctx context.Context, m *ModelProviderModelMutation) (Value, error) {
+	switch m.Op() {
+	case OpCreate:
+		return (&ModelProviderModelCreate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
+	case OpUpdate:
+		return (&ModelProviderModelUpdate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
+	case OpUpdateOne:
+		return (&ModelProviderModelUpdateOne{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
+	case OpDelete, OpDeleteOne:
+		return (&ModelProviderModelDelete{config: c.config, hooks: c.Hooks(), mutation: m}).Exec(ctx)
+	default:
+		return nil, fmt.Errorf("db: unknown ModelProviderModel mutation op: %q", m.Op())
+	}
+}
+
 // SettingClient is a client for the Setting schema.
 type SettingClient struct {
 	config
@@ -2551,13 +2867,13 @@ func (c *UserLoginHistoryClient) mutate(ctx context.Context, m *UserLoginHistory
 type (
 	hooks struct {
 		Admin, AdminLoginHistory, ApiKey, BillingPlan, BillingQuota, BillingRecord,
-		BillingUsage, InviteCode, Model, Setting, Task, TaskRecord, User, UserIdentity,
-		UserLoginHistory []ent.Hook
+		BillingUsage, InviteCode, Model, ModelProvider, ModelProviderModel, Setting,
+		Task, TaskRecord, User, UserIdentity, UserLoginHistory []ent.Hook
 	}
 	inters struct {
 		Admin, AdminLoginHistory, ApiKey, BillingPlan, BillingQuota, BillingRecord,
-		BillingUsage, InviteCode, Model, Setting, Task, TaskRecord, User, UserIdentity,
-		UserLoginHistory []ent.Interceptor
+		BillingUsage, InviteCode, Model, ModelProvider, ModelProviderModel, Setting,
+		Task, TaskRecord, User, UserIdentity, UserLoginHistory []ent.Interceptor
 	}
 )
 

backend/db/ent.go

@@ -21,6 +21,8 @@ import (
 	"github.com/chaitin/MonkeyCode/backend/db/billingusage"
 	"github.com/chaitin/MonkeyCode/backend/db/invitecode"
 	"github.com/chaitin/MonkeyCode/backend/db/model"
+	"github.com/chaitin/MonkeyCode/backend/db/modelprovider"
+	"github.com/chaitin/MonkeyCode/backend/db/modelprovidermodel"
 	"github.com/chaitin/MonkeyCode/backend/db/setting"
 	"github.com/chaitin/MonkeyCode/backend/db/task"
 	"github.com/chaitin/MonkeyCode/backend/db/taskrecord"
@@ -87,21 +89,23 @@ var (
 func checkColumn(table, column string) error {
 	initCheck.Do(func() {
 		columnCheck = sql.NewColumnCheck(map[string]func(string) bool{
-			admin.Table:             admin.ValidColumn,
-			adminloginhistory.Table: adminloginhistory.ValidColumn,
-			apikey.Table:            apikey.ValidColumn,
-			billingplan.Table:       billingplan.ValidColumn,
-			billingquota.Table:      billingquota.ValidColumn,
-			billingrecord.Table:     billingrecord.ValidColumn,
-			billingusage.Table:      billingusage.ValidColumn,
-			invitecode.Table:        invitecode.ValidColumn,
-			model.Table:             model.ValidColumn,
-			setting.Table:           setting.ValidColumn,
-			task.Table:              task.ValidColumn,
-			taskrecord.Table:        taskrecord.ValidColumn,
-			user.Table:              user.ValidColumn,
-			useridentity.Table:      useridentity.ValidColumn,
-			userloginhistory.Table:  userloginhistory.ValidColumn,
+			admin.Table:              admin.ValidColumn,
+			adminloginhistory.Table:  adminloginhistory.ValidColumn,
+			apikey.Table:             apikey.ValidColumn,
+			billingplan.Table:        billingplan.ValidColumn,
+			billingquota.Table:       billingquota.ValidColumn,
+			billingrecord.Table:      billingrecord.ValidColumn,
+			billingusage.Table:       billingusage.ValidColumn,
+			invitecode.Table:         invitecode.ValidColumn,
+			model.Table:              model.ValidColumn,
+			modelprovider.Table:      modelprovider.ValidColumn,
+			modelprovidermodel.Table: modelprovidermodel.ValidColumn,
+			setting.Table:            setting.ValidColumn,
+			task.Table:               task.ValidColumn,
+			taskrecord.Table:         taskrecord.ValidColumn,
+			user.Table:               user.ValidColumn,
+			useridentity.Table:       useridentity.ValidColumn,
+			userloginhistory.Table:   userloginhistory.ValidColumn,
 		})
 	})
 	return columnCheck(table, column)

backend/db/hook/hook.go

@@ -117,6 +117,30 @@ func (f ModelFunc) Mutate(ctx context.Context, m db.Mutation) (db.Value, error)
 	return nil, fmt.Errorf("unexpected mutation type %T. expect *db.ModelMutation", m)
 }
 
+// The ModelProviderFunc type is an adapter to allow the use of ordinary
+// function as ModelProvider mutator.
+type ModelProviderFunc func(context.Context, *db.ModelProviderMutation) (db.Value, error)
+
+// Mutate calls f(ctx, m).
+func (f ModelProviderFunc) Mutate(ctx context.Context, m db.Mutation) (db.Value, error) {
+	if mv, ok := m.(*db.ModelProviderMutation); ok {
+		return f(ctx, mv)
+	}
+	return nil, fmt.Errorf("unexpected mutation type %T. expect *db.ModelProviderMutation", m)
+}
+
+// The ModelProviderModelFunc type is an adapter to allow the use of ordinary
+// function as ModelProviderModel mutator.
+type ModelProviderModelFunc func(context.Context, *db.ModelProviderModelMutation) (db.Value, error)
+
+// Mutate calls f(ctx, m).
+func (f ModelProviderModelFunc) Mutate(ctx context.Context, m db.Mutation) (db.Value, error) {
+	if mv, ok := m.(*db.ModelProviderModelMutation); ok {
+		return f(ctx, mv)
+	}
+	return nil, fmt.Errorf("unexpected mutation type %T. expect *db.ModelProviderModelMutation", m)
+}
+
 // The SettingFunc type is an adapter to allow the use of ordinary
 // function as Setting mutator.
 type SettingFunc func(context.Context, *db.SettingMutation) (db.Value, error)

backend/db/intercept/intercept.go

@@ -17,6 +17,8 @@ import (
 	"github.com/chaitin/MonkeyCode/backend/db/billingusage"
 	"github.com/chaitin/MonkeyCode/backend/db/invitecode"
 	"github.com/chaitin/MonkeyCode/backend/db/model"
+	"github.com/chaitin/MonkeyCode/backend/db/modelprovider"
+	"github.com/chaitin/MonkeyCode/backend/db/modelprovidermodel"
 	"github.com/chaitin/MonkeyCode/backend/db/predicate"
 	"github.com/chaitin/MonkeyCode/backend/db/setting"
 	"github.com/chaitin/MonkeyCode/backend/db/task"
@@ -325,6 +327,60 @@ func (f TraverseModel) Traverse(ctx context.Context, q db.Query) error {
 	return fmt.Errorf("unexpected query type %T. expect *db.ModelQuery", q)
 }
 
+// The ModelProviderFunc type is an adapter to allow the use of ordinary function as a Querier.
+type ModelProviderFunc func(context.Context, *db.ModelProviderQuery) (db.Value, error)
+
+// Query calls f(ctx, q).
+func (f ModelProviderFunc) Query(ctx context.Context, q db.Query) (db.Value, error) {
+	if q, ok := q.(*db.ModelProviderQuery); ok {
+		return f(ctx, q)
+	}
+	return nil, fmt.Errorf("unexpected query type %T. expect *db.ModelProviderQuery", q)
+}
+
+// The TraverseModelProvider type is an adapter to allow the use of ordinary function as Traverser.
+type TraverseModelProvider func(context.Context, *db.ModelProviderQuery) error
+
+// Intercept is a dummy implementation of Intercept that returns the next Querier in the pipeline.
+func (f TraverseModelProvider) Intercept(next db.Querier) db.Querier {
+	return next
+}
+
+// Traverse calls f(ctx, q).
+func (f TraverseModelProvider) Traverse(ctx context.Context, q db.Query) error {
+	if q, ok := q.(*db.ModelProviderQuery); ok {
+		return f(ctx, q)
+	}
+	return fmt.Errorf("unexpected query type %T. expect *db.ModelProviderQuery", q)
+}
+
+// The ModelProviderModelFunc type is an adapter to allow the use of ordinary function as a Querier.
+type ModelProviderModelFunc func(context.Context, *db.ModelProviderModelQuery) (db.Value, error)
+
+// Query calls f(ctx, q).
+func (f ModelProviderModelFunc) Query(ctx context.Context, q db.Query) (db.Value, error) {
+	if q, ok := q.(*db.ModelProviderModelQuery); ok {
+		return f(ctx, q)
+	}
+	return nil, fmt.Errorf("unexpected query type %T. expect *db.ModelProviderModelQuery", q)
+}
+
+// The TraverseModelProviderModel type is an adapter to allow the use of ordinary function as Traverser.
+type TraverseModelProviderModel func(context.Context, *db.ModelProviderModelQuery) error
+
+// Intercept is a dummy implementation of Intercept that returns the next Querier in the pipeline.
+func (f TraverseModelProviderModel) Intercept(next db.Querier) db.Querier {
+	return next
+}
+
+// Traverse calls f(ctx, q).
+func (f TraverseModelProviderModel) Traverse(ctx context.Context, q db.Query) error {
+	if q, ok := q.(*db.ModelProviderModelQuery); ok {
+		return f(ctx, q)
+	}
+	return fmt.Errorf("unexpected query type %T. expect *db.ModelProviderModelQuery", q)
+}
+
 // The SettingFunc type is an adapter to allow the use of ordinary function as a Querier.
 type SettingFunc func(context.Context, *db.SettingQuery) (db.Value, error)
 
@@ -508,6 +564,10 @@ func NewQuery(q db.Query) (Query, error) {
 		return &query[*db.InviteCodeQuery, predicate.InviteCode, invitecode.OrderOption]{typ: db.TypeInviteCode, tq: q}, nil
 	case *db.ModelQuery:
 		return &query[*db.ModelQuery, predicate.Model, model.OrderOption]{typ: db.TypeModel, tq: q}, nil
+	case *db.ModelProviderQuery:
+		return &query[*db.ModelProviderQuery, predicate.ModelProvider, modelprovider.OrderOption]{typ: db.TypeModelProvider, tq: q}, nil
+	case *db.ModelProviderModelQuery:
+		return &query[*db.ModelProviderModelQuery, predicate.ModelProviderModel, modelprovidermodel.OrderOption]{typ: db.TypeModelProviderModel, tq: q}, nil
 	case *db.SettingQuery:
 		return &query[*db.SettingQuery, predicate.Setting, setting.OrderOption]{typ: db.TypeSetting, tq: q}, nil
 	case *db.TaskQuery:

backend/db/migrate/schema.go

@@ -185,6 +185,43 @@ var (
 			},
 		},
 	}
+	// ModelProvidersColumns holds the columns for the "model_providers" table.
+	ModelProvidersColumns = []*schema.Column{
+		{Name: "id", Type: field.TypeString, Unique: true},
+		{Name: "name", Type: field.TypeString},
+		{Name: "api_base", Type: field.TypeString},
+		{Name: "priority", Type: field.TypeInt, Default: 0},
+		{Name: "created_at", Type: field.TypeTime},
+		{Name: "updated_at", Type: field.TypeTime},
+	}
+	// ModelProvidersTable holds the schema information for the "model_providers" table.
+	ModelProvidersTable = &schema.Table{
+		Name:       "model_providers",
+		Columns:    ModelProvidersColumns,
+		PrimaryKey: []*schema.Column{ModelProvidersColumns[0]},
+	}
+	// ModelProviderModelsColumns holds the columns for the "model_provider_models" table.
+	ModelProviderModelsColumns = []*schema.Column{
+		{Name: "id", Type: field.TypeUUID},
+		{Name: "name", Type: field.TypeString},
+		{Name: "created_at", Type: field.TypeTime},
+		{Name: "updated_at", Type: field.TypeTime},
+		{Name: "provider_id", Type: field.TypeString, Nullable: true},
+	}
+	// ModelProviderModelsTable holds the schema information for the "model_provider_models" table.
+	ModelProviderModelsTable = &schema.Table{
+		Name:       "model_provider_models",
+		Columns:    ModelProviderModelsColumns,
+		PrimaryKey: []*schema.Column{ModelProviderModelsColumns[0]},
+		ForeignKeys: []*schema.ForeignKey{
+			{
+				Symbol:     "model_provider_models_model_providers_models",
+				Columns:    []*schema.Column{ModelProviderModelsColumns[4]},
+				RefColumns: []*schema.Column{ModelProvidersColumns[0]},
+				OnDelete:   schema.SetNull,
+			},
+		},
+	}
 	// SettingsColumns holds the columns for the "settings" table.
 	SettingsColumns = []*schema.Column{
 		{Name: "id", Type: field.TypeUUID},
@@ -349,6 +386,8 @@ var (
 		BillingUsagesTable,
 		InviteCodesTable,
 		ModelsTable,
+		ModelProvidersTable,
+		ModelProviderModelsTable,
 		SettingsTable,
 		TasksTable,
 		TaskRecordsTable,
@@ -388,6 +427,13 @@ func init() {
 	ModelsTable.Annotation = &entsql.Annotation{
 		Table: "models",
 	}
+	ModelProvidersTable.Annotation = &entsql.Annotation{
+		Table: "model_providers",
+	}
+	ModelProviderModelsTable.ForeignKeys[0].RefTable = ModelProvidersTable
+	ModelProviderModelsTable.Annotation = &entsql.Annotation{
+		Table: "model_provider_models",
+	}
 	SettingsTable.Annotation = &entsql.Annotation{
 		Table: "settings",
 	}

backend/db/modelprovider.go

@@ -0,0 +1,176 @@
+// Code generated by ent, DO NOT EDIT.
+
+package db
+
+import (
+	"fmt"
+	"strings"
+	"time"
+
+	"entgo.io/ent"
+	"entgo.io/ent/dialect/sql"
+	"github.com/chaitin/MonkeyCode/backend/db/modelprovider"
+)
+
+// ModelProvider is the model entity for the ModelProvider schema.
+type ModelProvider struct {
+	config `json:"-"`
+	// ID of the ent.
+	ID string `json:"id,omitempty"`
+	// Name holds the value of the "name" field.
+	Name string `json:"name,omitempty"`
+	// APIBase holds the value of the "api_base" field.
+	APIBase string `json:"api_base,omitempty"`
+	// Priority holds the value of the "priority" field.
+	Priority int `json:"priority,omitempty"`
+	// CreatedAt holds the value of the "created_at" field.
+	CreatedAt time.Time `json:"created_at,omitempty"`
+	// UpdatedAt holds the value of the "updated_at" field.
+	UpdatedAt time.Time `json:"updated_at,omitempty"`
+	// Edges holds the relations/edges for other nodes in the graph.
+	// The values are being populated by the ModelProviderQuery when eager-loading is set.
+	Edges        ModelProviderEdges `json:"edges"`
+	selectValues sql.SelectValues
+}
+
+// ModelProviderEdges holds the relations/edges for other nodes in the graph.
+type ModelProviderEdges struct {
+	// Models holds the value of the models edge.
+	Models []*ModelProviderModel `json:"models,omitempty"`
+	// loadedTypes holds the information for reporting if a
+	// type was loaded (or requested) in eager-loading or not.
+	loadedTypes [1]bool
+}
+
+// ModelsOrErr returns the Models value or an error if the edge
+// was not loaded in eager-loading.
+func (e ModelProviderEdges) ModelsOrErr() ([]*ModelProviderModel, error) {
+	if e.loadedTypes[0] {
+		return e.Models, nil
+	}
+	return nil, &NotLoadedError{edge: "models"}
+}
+
+// scanValues returns the types for scanning values from sql.Rows.
+func (*ModelProvider) scanValues(columns []string) ([]any, error) {
+	values := make([]any, len(columns))
+	for i := range columns {
+		switch columns[i] {
+		case modelprovider.FieldPriority:
+			values[i] = new(sql.NullInt64)
+		case modelprovider.FieldID, modelprovider.FieldName, modelprovider.FieldAPIBase:
+			values[i] = new(sql.NullString)
+		case modelprovider.FieldCreatedAt, modelprovider.FieldUpdatedAt:
+			values[i] = new(sql.NullTime)
+		default:
+			values[i] = new(sql.UnknownType)
+		}
+	}
+	return values, nil
+}
+
+// assignValues assigns the values that were returned from sql.Rows (after scanning)
+// to the ModelProvider fields.
+func (mp *ModelProvider) assignValues(columns []string, values []any) error {
+	if m, n := len(values), len(columns); m < n {
+		return fmt.Errorf("mismatch number of scan values: %d != %d", m, n)
+	}
+	for i := range columns {
+		switch columns[i] {
+		case modelprovider.FieldID:
+			if value, ok := values[i].(*sql.NullString); !ok {
+				return fmt.Errorf("unexpected type %T for field id", values[i])
+			} else if value.Valid {
+				mp.ID = value.String
+			}
+		case modelprovider.FieldName:
+			if value, ok := values[i].(*sql.NullString); !ok {
+				return fmt.Errorf("unexpected type %T for field name", values[i])
+			} else if value.Valid {
+				mp.Name = value.String
+			}
+		case modelprovider.FieldAPIBase:
+			if value, ok := values[i].(*sql.NullString); !ok {
+				return fmt.Errorf("unexpected type %T for field api_base", values[i])
+			} else if value.Valid {
+				mp.APIBase = value.String
+			}
+		case modelprovider.FieldPriority:
+			if value, ok := values[i].(*sql.NullInt64); !ok {
+				return fmt.Errorf("unexpected type %T for field priority", values[i])
+			} else if value.Valid {
+				mp.Priority = int(value.Int64)
+			}
+		case modelprovider.FieldCreatedAt:
+			if value, ok := values[i].(*sql.NullTime); !ok {
+				return fmt.Errorf("unexpected type %T for field created_at", values[i])
+			} else if value.Valid {
+				mp.CreatedAt = value.Time
+			}
+		case modelprovider.FieldUpdatedAt:
+			if value, ok := values[i].(*sql.NullTime); !ok {
+				return fmt.Errorf("unexpected type %T for field updated_at", values[i])
+			} else if value.Valid {
+				mp.UpdatedAt = value.Time
+			}
+		default:
+			mp.selectValues.Set(columns[i], values[i])
+		}
+	}
+	return nil
+}
+
+// Value returns the ent.Value that was dynamically selected and assigned to the ModelProvider.
+// This includes values selected through modifiers, order, etc.
+func (mp *ModelProvider) Value(name string) (ent.Value, error) {
+	return mp.selectValues.Get(name)
+}
+
+// QueryModels queries the "models" edge of the ModelProvider entity.
+func (mp *ModelProvider) QueryModels() *ModelProviderModelQuery {
+	return NewModelProviderClient(mp.config).QueryModels(mp)
+}
+
+// Update returns a builder for updating this ModelProvider.
+// Note that you need to call ModelProvider.Unwrap() before calling this method if this ModelProvider
+// was returned from a transaction, and the transaction was committed or rolled back.
+func (mp *ModelProvider) Update() *ModelProviderUpdateOne {
+	return NewModelProviderClient(mp.config).UpdateOne(mp)
+}
+
+// Unwrap unwraps the ModelProvider entity that was returned from a transaction after it was closed,
+// so that all future queries will be executed through the driver which created the transaction.
+func (mp *ModelProvider) Unwrap() *ModelProvider {
+	_tx, ok := mp.config.driver.(*txDriver)
+	if !ok {
+		panic("db: ModelProvider is not a transactional entity")
+	}
+	mp.config.driver = _tx.drv
+	return mp
+}
+
+// String implements the fmt.Stringer.
+func (mp *ModelProvider) String() string {
+	var builder strings.Builder
+	builder.WriteString("ModelProvider(")
+	builder.WriteString(fmt.Sprintf("id=%v, ", mp.ID))
+	builder.WriteString("name=")
+	builder.WriteString(mp.Name)
+	builder.WriteString(", ")
+	builder.WriteString("api_base=")
+	builder.WriteString(mp.APIBase)
+	builder.WriteString(", ")
+	builder.WriteString("priority=")
+	builder.WriteString(fmt.Sprintf("%v", mp.Priority))
+	builder.WriteString(", ")
+	builder.WriteString("created_at=")
+	builder.WriteString(mp.CreatedAt.Format(time.ANSIC))
+	builder.WriteString(", ")
+	builder.WriteString("updated_at=")
+	builder.WriteString(mp.UpdatedAt.Format(time.ANSIC))
+	builder.WriteByte(')')
+	return builder.String()
+}
+
+// ModelProviders is a parsable slice of ModelProvider.
+type ModelProviders []*ModelProvider

backend/db/modelprovider/modelprovider.go

@@ -0,0 +1,129 @@
+// Code generated by ent, DO NOT EDIT.
+
+package modelprovider
+
+import (
+	"time"
+
+	"entgo.io/ent/dialect/sql"
+	"entgo.io/ent/dialect/sql/sqlgraph"
+)
+
+const (
+	// Label holds the string label denoting the modelprovider type in the database.
+	Label = "model_provider"
+	// FieldID holds the string denoting the id field in the database.
+	FieldID = "id"
+	// FieldName holds the string denoting the name field in the database.
+	FieldName = "name"
+	// FieldAPIBase holds the string denoting the api_base field in the database.
+	FieldAPIBase = "api_base"
+	// FieldPriority holds the string denoting the priority field in the database.
+	FieldPriority = "priority"
+	// FieldCreatedAt holds the string denoting the created_at field in the database.
+	FieldCreatedAt = "created_at"
+	// FieldUpdatedAt holds the string denoting the updated_at field in the database.
+	FieldUpdatedAt = "updated_at"
+	// EdgeModels holds the string denoting the models edge name in mutations.
+	EdgeModels = "models"
+	// Table holds the table name of the modelprovider in the database.
+	Table = "model_providers"
+	// ModelsTable is the table that holds the models relation/edge.
+	ModelsTable = "model_provider_models"
+	// ModelsInverseTable is the table name for the ModelProviderModel entity.
+	// It exists in this package in order to avoid circular dependency with the "modelprovidermodel" package.
+	ModelsInverseTable = "model_provider_models"
+	// ModelsColumn is the table column denoting the models relation/edge.
+	ModelsColumn = "provider_id"
+)
+
+// Columns holds all SQL columns for modelprovider fields.
+var Columns = []string{
+	FieldID,
+	FieldName,
+	FieldAPIBase,
+	FieldPriority,
+	FieldCreatedAt,
+	FieldUpdatedAt,
+}
+
+// ValidColumn reports if the column name is valid (part of the table columns).
+func ValidColumn(column string) bool {
+	for i := range Columns {
+		if column == Columns[i] {
+			return true
+		}
+	}
+	return false
+}
+
+var (
+	// NameValidator is a validator for the "name" field. It is called by the builders before save.
+	NameValidator func(string) error
+	// APIBaseValidator is a validator for the "api_base" field. It is called by the builders before save.
+	APIBaseValidator func(string) error
+	// DefaultPriority holds the default value on creation for the "priority" field.
+	DefaultPriority int
+	// DefaultCreatedAt holds the default value on creation for the "created_at" field.
+	DefaultCreatedAt func() time.Time
+	// DefaultUpdatedAt holds the default value on creation for the "updated_at" field.
+	DefaultUpdatedAt func() time.Time
+	// UpdateDefaultUpdatedAt holds the default value on update for the "updated_at" field.
+	UpdateDefaultUpdatedAt func() time.Time
+	// IDValidator is a validator for the "id" field. It is called by the builders before save.
+	IDValidator func(string) error
+)
+
+// OrderOption defines the ordering options for the ModelProvider queries.
+type OrderOption func(*sql.Selector)
+
+// ByID orders the results by the id field.
+func ByID(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldID, opts...).ToFunc()
+}
+
+// ByName orders the results by the name field.
+func ByName(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldName, opts...).ToFunc()
+}
+
+// ByAPIBase orders the results by the api_base field.
+func ByAPIBase(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldAPIBase, opts...).ToFunc()
+}
+
+// ByPriority orders the results by the priority field.
+func ByPriority(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldPriority, opts...).ToFunc()
+}
+
+// ByCreatedAt orders the results by the created_at field.
+func ByCreatedAt(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldCreatedAt, opts...).ToFunc()
+}
+
+// ByUpdatedAt orders the results by the updated_at field.
+func ByUpdatedAt(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldUpdatedAt, opts...).ToFunc()
+}
+
+// ByModelsCount orders the results by models count.
+func ByModelsCount(opts ...sql.OrderTermOption) OrderOption {
+	return func(s *sql.Selector) {
+		sqlgraph.OrderByNeighborsCount(s, newModelsStep(), opts...)
+	}
+}
+
+// ByModels orders the results by models terms.
+func ByModels(term sql.OrderTerm, terms ...sql.OrderTerm) OrderOption {
+	return func(s *sql.Selector) {
+		sqlgraph.OrderByNeighborTerms(s, newModelsStep(), append([]sql.OrderTerm{term}, terms...)...)
+	}
+}
+func newModelsStep() *sqlgraph.Step {
+	return sqlgraph.NewStep(
+		sqlgraph.From(Table, FieldID),
+		sqlgraph.To(ModelsInverseTable, FieldID),
+		sqlgraph.Edge(sqlgraph.O2M, false, ModelsTable, ModelsColumn),
+	)
+}

backend/db/modelprovider/where.go

@@ -0,0 +1,379 @@
+// Code generated by ent, DO NOT EDIT.
+
+package modelprovider
+
+import (
+	"time"
+
+	"entgo.io/ent/dialect/sql"
+	"entgo.io/ent/dialect/sql/sqlgraph"
+	"github.com/chaitin/MonkeyCode/backend/db/predicate"
+)
+
+// ID filters vertices based on their ID field.
+func ID(id string) predicate.ModelProvider {
+	return predicate.ModelProvider(sql.FieldEQ(FieldID, id))
+}
+
+// IDEQ applies the EQ predicate on the ID field.
+func IDEQ(id string) predicate.ModelProvider {
+	return predicate.ModelProvider(sql.FieldEQ(FieldID, id))
+}
+
+// IDNEQ applies the NEQ predicate on the ID field.
+func IDNEQ(id string) predicate.ModelProvider {
+	return predicate.ModelProvider(sql.FieldNEQ(FieldID, id))
+}
+
+// IDIn applies the In predicate on the ID field.
+func IDIn(ids ...string) predicate.ModelProvider {
+	return predicate.ModelProvider(sql.FieldIn(FieldID, ids...))
+}
+
+// IDNotIn applies the NotIn predicate on the ID field.
+func IDNotIn(ids ...string) predicate.ModelProvider {
+	return predicate.ModelProvider(sql.FieldNotIn(FieldID, ids...))
+}
+
+// IDGT applies the GT predicate on the ID field.
+func IDGT(id string) predicate.ModelProvider {
+	return predicate.ModelProvider(sql.FieldGT(FieldID, id))
+}
+
+// IDGTE applies the GTE predicate on the ID field.
+func IDGTE(id string) predicate.ModelProvider {
+	return predicate.ModelProvider(sql.FieldGTE(FieldID, id))
+}
+
+// IDLT applies the LT predicate on the ID field.
+func IDLT(id string) predicate.ModelProvider {
+	return predicate.ModelProvider(sql.FieldLT(FieldID, id))
+}
+
+// IDLTE applies the LTE predicate on the ID field.
+func IDLTE(id string) predicate.ModelProvider {
+	return predicate.ModelProvider(sql.FieldLTE(FieldID, id))
+}
+
+// IDEqualFold applies the EqualFold predicate on the ID field.
+func IDEqualFold(id string) predicate.ModelProvider {
+	return predicate.ModelProvider(sql.FieldEqualFold(FieldID, id))
+}
+
+// IDContainsFold applies the ContainsFold predicate on the ID field.
+func IDContainsFold(id string) predicate.ModelProvider {
+	return predicate.ModelProvider(sql.FieldContainsFold(FieldID, id))
+}
+
+// Name applies equality check predicate on the "name" field. It's identical to NameEQ.
+func Name(v string) predicate.ModelProvider {
+	return predicate.ModelProvider(sql.FieldEQ(FieldName, v))
+}
+
+// APIBase applies equality check predicate on the "api_base" field. It's identical to APIBaseEQ.
+func APIBase(v string) predicate.ModelProvider {
+	return predicate.ModelProvider(sql.FieldEQ(FieldAPIBase, v))
+}
+
+// Priority applies equality check predicate on the "priority" field. It's identical to PriorityEQ.
+func Priority(v int) predicate.ModelProvider {
+	return predicate.ModelProvider(sql.FieldEQ(FieldPriority, v))
+}
+
+// CreatedAt applies equality check predicate on the "created_at" field. It's identical to CreatedAtEQ.
+func CreatedAt(v time.Time) predicate.ModelProvider {
+	return predicate.ModelProvider(sql.FieldEQ(FieldCreatedAt, v))
+}
+
+// UpdatedAt applies equality check predicate on the "updated_at" field. It's identical to UpdatedAtEQ.
+func UpdatedAt(v time.Time) predicate.ModelProvider {
+	return predicate.ModelProvider(sql.FieldEQ(FieldUpdatedAt, v))
+}
+
+// NameEQ applies the EQ predicate on the "name" field.
+func NameEQ(v string) predicate.ModelProvider {
+	return predicate.ModelProvider(sql.FieldEQ(FieldName, v))
+}
+
+// NameNEQ applies the NEQ predicate on the "name" field.
+func NameNEQ(v string) predicate.ModelProvider {
+	return predicate.ModelProvider(sql.FieldNEQ(FieldName, v))
+}
+
+// NameIn applies the In predicate on the "name" field.
+func NameIn(vs ...string) predicate.ModelProvider {
+	return predicate.ModelProvider(sql.FieldIn(FieldName, vs...))
+}
+
+// NameNotIn applies the NotIn predicate on the "name" field.
+func NameNotIn(vs ...string) predicate.ModelProvider {
+	return predicate.ModelProvider(sql.FieldNotIn(FieldName, vs...))
+}
+
+// NameGT applies the GT predicate on the "name" field.
+func NameGT(v string) predicate.ModelProvider {
+	return predicate.ModelProvider(sql.FieldGT(FieldName, v))
+}
+
+// NameGTE applies the GTE predicate on the "name" field.
+func NameGTE(v string) predicate.ModelProvider {
+	return predicate.ModelProvider(sql.FieldGTE(FieldName, v))
+}
+
+// NameLT applies the LT predicate on the "name" field.
+func NameLT(v string) predicate.ModelProvider {
+	return predicate.ModelProvider(sql.FieldLT(FieldName, v))
+}
+
+// NameLTE applies the LTE predicate on the "name" field.
+func NameLTE(v string) predicate.ModelProvider {
+	return predicate.ModelProvider(sql.FieldLTE(FieldName, v))
+}
+
+// NameContains applies the Contains predicate on the "name" field.
+func NameContains(v string) predicate.ModelProvider {
+	return predicate.ModelProvider(sql.FieldContains(FieldName, v))
+}
+
+// NameHasPrefix applies the HasPrefix predicate on the "name" field.
+func NameHasPrefix(v string) predicate.ModelProvider {
+	return predicate.ModelProvider(sql.FieldHasPrefix(FieldName, v))
+}
+
+// NameHasSuffix applies the HasSuffix predicate on the "name" field.
+func NameHasSuffix(v string) predicate.ModelProvider {
+	return predicate.ModelProvider(sql.FieldHasSuffix(FieldName, v))
+}
+
+// NameEqualFold applies the EqualFold predicate on the "name" field.
+func NameEqualFold(v string) predicate.ModelProvider {
+	return predicate.ModelProvider(sql.FieldEqualFold(FieldName, v))
+}
+
+// NameContainsFold applies the ContainsFold predicate on the "name" field.
+func NameContainsFold(v string) predicate.ModelProvider {
+	return predicate.ModelProvider(sql.FieldContainsFold(FieldName, v))
+}
+
+// APIBaseEQ applies the EQ predicate on the "api_base" field.
+func APIBaseEQ(v string) predicate.ModelProvider {
+	return predicate.ModelProvider(sql.FieldEQ(FieldAPIBase, v))
+}
+
+// APIBaseNEQ applies the NEQ predicate on the "api_base" field.
+func APIBaseNEQ(v string) predicate.ModelProvider {
+	return predicate.ModelProvider(sql.FieldNEQ(FieldAPIBase, v))
+}
+
+// APIBaseIn applies the In predicate on the "api_base" field.
+func APIBaseIn(vs ...string) predicate.ModelProvider {
+	return predicate.ModelProvider(sql.FieldIn(FieldAPIBase, vs...))
+}
+
+// APIBaseNotIn applies the NotIn predicate on the "api_base" field.
+func APIBaseNotIn(vs ...string) predicate.ModelProvider {
+	return predicate.ModelProvider(sql.FieldNotIn(FieldAPIBase, vs...))
+}
+
+// APIBaseGT applies the GT predicate on the "api_base" field.
+func APIBaseGT(v string) predicate.ModelProvider {
+	return predicate.ModelProvider(sql.FieldGT(FieldAPIBase, v))
+}
+
+// APIBaseGTE applies the GTE predicate on the "api_base" field.
+func APIBaseGTE(v string) predicate.ModelProvider {
+	return predicate.ModelProvider(sql.FieldGTE(FieldAPIBase, v))
+}
+
+// APIBaseLT applies the LT predicate on the "api_base" field.
+func APIBaseLT(v string) predicate.ModelProvider {
+	return predicate.ModelProvider(sql.FieldLT(FieldAPIBase, v))
+}
+
+// APIBaseLTE applies the LTE predicate on the "api_base" field.
+func APIBaseLTE(v string) predicate.ModelProvider {
+	return predicate.ModelProvider(sql.FieldLTE(FieldAPIBase, v))
+}
+
+// APIBaseContains applies the Contains predicate on the "api_base" field.
+func APIBaseContains(v string) predicate.ModelProvider {
+	return predicate.ModelProvider(sql.FieldContains(FieldAPIBase, v))
+}
+
+// APIBaseHasPrefix applies the HasPrefix predicate on the "api_base" field.
+func APIBaseHasPrefix(v string) predicate.ModelProvider {
+	return predicate.ModelProvider(sql.FieldHasPrefix(FieldAPIBase, v))
+}
+
+// APIBaseHasSuffix applies the HasSuffix predicate on the "api_base" field.
+func APIBaseHasSuffix(v string) predicate.ModelProvider {
+	return predicate.ModelProvider(sql.FieldHasSuffix(FieldAPIBase, v))
+}
+
+// APIBaseEqualFold applies the EqualFold predicate on the "api_base" field.
+func APIBaseEqualFold(v string) predicate.ModelProvider {
+	return predicate.ModelProvider(sql.FieldEqualFold(FieldAPIBase, v))
+}
+
+// APIBaseContainsFold applies the ContainsFold predicate on the "api_base" field.
+func APIBaseContainsFold(v string) predicate.ModelProvider {
+	return predicate.ModelProvider(sql.FieldContainsFold(FieldAPIBase, v))
+}
+
+// PriorityEQ applies the EQ predicate on the "priority" field.
+func PriorityEQ(v int) predicate.ModelProvider {
+	return predicate.ModelProvider(sql.FieldEQ(FieldPriority, v))
+}
+
+// PriorityNEQ applies the NEQ predicate on the "priority" field.
+func PriorityNEQ(v int) predicate.ModelProvider {
+	return predicate.ModelProvider(sql.FieldNEQ(FieldPriority, v))
+}
+
+// PriorityIn applies the In predicate on the "priority" field.
+func PriorityIn(vs ...int) predicate.ModelProvider {
+	return predicate.ModelProvider(sql.FieldIn(FieldPriority, vs...))
+}
+
+// PriorityNotIn applies the NotIn predicate on the "priority" field.
+func PriorityNotIn(vs ...int) predicate.ModelProvider {
+	return predicate.ModelProvider(sql.FieldNotIn(FieldPriority, vs...))
+}
+
+// PriorityGT applies the GT predicate on the "priority" field.
+func PriorityGT(v int) predicate.ModelProvider {
+	return predicate.ModelProvider(sql.FieldGT(FieldPriority, v))
+}
+
+// PriorityGTE applies the GTE predicate on the "priority" field.
+func PriorityGTE(v int) predicate.ModelProvider {
+	return predicate.ModelProvider(sql.FieldGTE(FieldPriority, v))
+}
+
+// PriorityLT applies the LT predicate on the "priority" field.
+func PriorityLT(v int) predicate.ModelProvider {
+	return predicate.ModelProvider(sql.FieldLT(FieldPriority, v))
+}
+
+// PriorityLTE applies the LTE predicate on the "priority" field.
+func PriorityLTE(v int) predicate.ModelProvider {
+	return predicate.ModelProvider(sql.FieldLTE(FieldPriority, v))
+}
+
+// CreatedAtEQ applies the EQ predicate on the "created_at" field.
+func CreatedAtEQ(v time.Time) predicate.ModelProvider {
+	return predicate.ModelProvider(sql.FieldEQ(FieldCreatedAt, v))
+}
+
+// CreatedAtNEQ applies the NEQ predicate on the "created_at" field.
+func CreatedAtNEQ(v time.Time) predicate.ModelProvider {
+	return predicate.ModelProvider(sql.FieldNEQ(FieldCreatedAt, v))
+}
+
+// CreatedAtIn applies the In predicate on the "created_at" field.
+func CreatedAtIn(vs ...time.Time) predicate.ModelProvider {
+	return predicate.ModelProvider(sql.FieldIn(FieldCreatedAt, vs...))
+}
+
+// CreatedAtNotIn applies the NotIn predicate on the "created_at" field.
+func CreatedAtNotIn(vs ...time.Time) predicate.ModelProvider {
+	return predicate.ModelProvider(sql.FieldNotIn(FieldCreatedAt, vs...))
+}
+
+// CreatedAtGT applies the GT predicate on the "created_at" field.
+func CreatedAtGT(v time.Time) predicate.ModelProvider {
+	return predicate.ModelProvider(sql.FieldGT(FieldCreatedAt, v))
+}
+
+// CreatedAtGTE applies the GTE predicate on the "created_at" field.
+func CreatedAtGTE(v time.Time) predicate.ModelProvider {
+	return predicate.ModelProvider(sql.FieldGTE(FieldCreatedAt, v))
+}
+
+// CreatedAtLT applies the LT predicate on the "created_at" field.
+func CreatedAtLT(v time.Time) predicate.ModelProvider {
+	return predicate.ModelProvider(sql.FieldLT(FieldCreatedAt, v))
+}
+
+// CreatedAtLTE applies the LTE predicate on the "created_at" field.
+func CreatedAtLTE(v time.Time) predicate.ModelProvider {
+	return predicate.ModelProvider(sql.FieldLTE(FieldCreatedAt, v))
+}
+
+// UpdatedAtEQ applies the EQ predicate on the "updated_at" field.
+func UpdatedAtEQ(v time.Time) predicate.ModelProvider {
+	return predicate.ModelProvider(sql.FieldEQ(FieldUpdatedAt, v))
+}
+
+// UpdatedAtNEQ applies the NEQ predicate on the "updated_at" field.
+func UpdatedAtNEQ(v time.Time) predicate.ModelProvider {
+	return predicate.ModelProvider(sql.FieldNEQ(FieldUpdatedAt, v))
+}
+
+// UpdatedAtIn applies the In predicate on the "updated_at" field.
+func UpdatedAtIn(vs ...time.Time) predicate.ModelProvider {
+	return predicate.ModelProvider(sql.FieldIn(FieldUpdatedAt, vs...))
+}
+
+// UpdatedAtNotIn applies the NotIn predicate on the "updated_at" field.
+func UpdatedAtNotIn(vs ...time.Time) predicate.ModelProvider {
+	return predicate.ModelProvider(sql.FieldNotIn(FieldUpdatedAt, vs...))
+}
+
+// UpdatedAtGT applies the GT predicate on the "updated_at" field.
+func UpdatedAtGT(v time.Time) predicate.ModelProvider {
+	return predicate.ModelProvider(sql.FieldGT(FieldUpdatedAt, v))
+}
+
+// UpdatedAtGTE applies the GTE predicate on the "updated_at" field.
+func UpdatedAtGTE(v time.Time) predicate.ModelProvider {
+	return predicate.ModelProvider(sql.FieldGTE(FieldUpdatedAt, v))
+}
+
+// UpdatedAtLT applies the LT predicate on the "updated_at" field.
+func UpdatedAtLT(v time.Time) predicate.ModelProvider {
+	return predicate.ModelProvider(sql.FieldLT(FieldUpdatedAt, v))
+}
+
+// UpdatedAtLTE applies the LTE predicate on the "updated_at" field.
+func UpdatedAtLTE(v time.Time) predicate.ModelProvider {
+	return predicate.ModelProvider(sql.FieldLTE(FieldUpdatedAt, v))
+}
+
+// HasModels applies the HasEdge predicate on the "models" edge.
+func HasModels() predicate.ModelProvider {
+	return predicate.ModelProvider(func(s *sql.Selector) {
+		step := sqlgraph.NewStep(
+			sqlgraph.From(Table, FieldID),
+			sqlgraph.Edge(sqlgraph.O2M, false, ModelsTable, ModelsColumn),
+		)
+		sqlgraph.HasNeighbors(s, step)
+	})
+}
+
+// HasModelsWith applies the HasEdge predicate on the "models" edge with a given conditions (other predicates).
+func HasModelsWith(preds ...predicate.ModelProviderModel) predicate.ModelProvider {
+	return predicate.ModelProvider(func(s *sql.Selector) {
+		step := newModelsStep()
+		sqlgraph.HasNeighborsWith(s, step, func(s *sql.Selector) {
+			for _, p := range preds {
+				p(s)
+			}
+		})
+	})
+}
+
+// And groups predicates with the AND operator between them.
+func And(predicates ...predicate.ModelProvider) predicate.ModelProvider {
+	return predicate.ModelProvider(sql.AndPredicates(predicates...))
+}
+
+// Or groups predicates with the OR operator between them.
+func Or(predicates ...predicate.ModelProvider) predicate.ModelProvider {
+	return predicate.ModelProvider(sql.OrPredicates(predicates...))
+}
+
+// Not applies the not operator on the given predicate.
+func Not(p predicate.ModelProvider) predicate.ModelProvider {
+	return predicate.ModelProvider(sql.NotPredicates(p))
+}

backend/db/modelprovider_create.go

@@ -0,0 +1,812 @@
+// Code generated by ent, DO NOT EDIT.
+
+package db
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"time"
+
+	"entgo.io/ent/dialect"
+	"entgo.io/ent/dialect/sql"
+	"entgo.io/ent/dialect/sql/sqlgraph"
+	"entgo.io/ent/schema/field"
+	"github.com/chaitin/MonkeyCode/backend/db/modelprovider"
+	"github.com/chaitin/MonkeyCode/backend/db/modelprovidermodel"
+	"github.com/google/uuid"
+)
+
+// ModelProviderCreate is the builder for creating a ModelProvider entity.
+type ModelProviderCreate struct {
+	config
+	mutation *ModelProviderMutation
+	hooks    []Hook
+	conflict []sql.ConflictOption
+}
+
+// SetName sets the "name" field.
+func (mpc *ModelProviderCreate) SetName(s string) *ModelProviderCreate {
+	mpc.mutation.SetName(s)
+	return mpc
+}
+
+// SetAPIBase sets the "api_base" field.
+func (mpc *ModelProviderCreate) SetAPIBase(s string) *ModelProviderCreate {
+	mpc.mutation.SetAPIBase(s)
+	return mpc
+}
+
+// SetPriority sets the "priority" field.
+func (mpc *ModelProviderCreate) SetPriority(i int) *ModelProviderCreate {
+	mpc.mutation.SetPriority(i)
+	return mpc
+}
+
+// SetNillablePriority sets the "priority" field if the given value is not nil.
+func (mpc *ModelProviderCreate) SetNillablePriority(i *int) *ModelProviderCreate {
+	if i != nil {
+		mpc.SetPriority(*i)
+	}
+	return mpc
+}
+
+// SetCreatedAt sets the "created_at" field.
+func (mpc *ModelProviderCreate) SetCreatedAt(t time.Time) *ModelProviderCreate {
+	mpc.mutation.SetCreatedAt(t)
+	return mpc
+}
+
+// SetNillableCreatedAt sets the "created_at" field if the given value is not nil.
+func (mpc *ModelProviderCreate) SetNillableCreatedAt(t *time.Time) *ModelProviderCreate {
+	if t != nil {
+		mpc.SetCreatedAt(*t)
+	}
+	return mpc
+}
+
+// SetUpdatedAt sets the "updated_at" field.
+func (mpc *ModelProviderCreate) SetUpdatedAt(t time.Time) *ModelProviderCreate {
+	mpc.mutation.SetUpdatedAt(t)
+	return mpc
+}
+
+// SetNillableUpdatedAt sets the "updated_at" field if the given value is not nil.
+func (mpc *ModelProviderCreate) SetNillableUpdatedAt(t *time.Time) *ModelProviderCreate {
+	if t != nil {
+		mpc.SetUpdatedAt(*t)
+	}
+	return mpc
+}
+
+// SetID sets the "id" field.
+func (mpc *ModelProviderCreate) SetID(s string) *ModelProviderCreate {
+	mpc.mutation.SetID(s)
+	return mpc
+}
+
+// AddModelIDs adds the "models" edge to the ModelProviderModel entity by IDs.
+func (mpc *ModelProviderCreate) AddModelIDs(ids ...uuid.UUID) *ModelProviderCreate {
+	mpc.mutation.AddModelIDs(ids...)
+	return mpc
+}
+
+// AddModels adds the "models" edges to the ModelProviderModel entity.
+func (mpc *ModelProviderCreate) AddModels(m ...*ModelProviderModel) *ModelProviderCreate {
+	ids := make([]uuid.UUID, len(m))
+	for i := range m {
+		ids[i] = m[i].ID
+	}
+	return mpc.AddModelIDs(ids...)
+}
+
+// Mutation returns the ModelProviderMutation object of the builder.
+func (mpc *ModelProviderCreate) Mutation() *ModelProviderMutation {
+	return mpc.mutation
+}
+
+// Save creates the ModelProvider in the database.
+func (mpc *ModelProviderCreate) Save(ctx context.Context) (*ModelProvider, error) {
+	mpc.defaults()
+	return withHooks(ctx, mpc.sqlSave, mpc.mutation, mpc.hooks)
+}
+
+// SaveX calls Save and panics if Save returns an error.
+func (mpc *ModelProviderCreate) SaveX(ctx context.Context) *ModelProvider {
+	v, err := mpc.Save(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return v
+}
+
+// Exec executes the query.
+func (mpc *ModelProviderCreate) Exec(ctx context.Context) error {
+	_, err := mpc.Save(ctx)
+	return err
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (mpc *ModelProviderCreate) ExecX(ctx context.Context) {
+	if err := mpc.Exec(ctx); err != nil {
+		panic(err)
+	}
+}
+
+// defaults sets the default values of the builder before save.
+func (mpc *ModelProviderCreate) defaults() {
+	if _, ok := mpc.mutation.Priority(); !ok {
+		v := modelprovider.DefaultPriority
+		mpc.mutation.SetPriority(v)
+	}
+	if _, ok := mpc.mutation.CreatedAt(); !ok {
+		v := modelprovider.DefaultCreatedAt()
+		mpc.mutation.SetCreatedAt(v)
+	}
+	if _, ok := mpc.mutation.UpdatedAt(); !ok {
+		v := modelprovider.DefaultUpdatedAt()
+		mpc.mutation.SetUpdatedAt(v)
+	}
+}
+
+// check runs all checks and user-defined validators on the builder.
+func (mpc *ModelProviderCreate) check() error {
+	if _, ok := mpc.mutation.Name(); !ok {
+		return &ValidationError{Name: "name", err: errors.New(`db: missing required field "ModelProvider.name"`)}
+	}
+	if v, ok := mpc.mutation.Name(); ok {
+		if err := modelprovider.NameValidator(v); err != nil {
+			return &ValidationError{Name: "name", err: fmt.Errorf(`db: validator failed for field "ModelProvider.name": %w`, err)}
+		}
+	}
+	if _, ok := mpc.mutation.APIBase(); !ok {
+		return &ValidationError{Name: "api_base", err: errors.New(`db: missing required field "ModelProvider.api_base"`)}
+	}
+	if v, ok := mpc.mutation.APIBase(); ok {
+		if err := modelprovider.APIBaseValidator(v); err != nil {
+			return &ValidationError{Name: "api_base", err: fmt.Errorf(`db: validator failed for field "ModelProvider.api_base": %w`, err)}
+		}
+	}
+	if _, ok := mpc.mutation.Priority(); !ok {
+		return &ValidationError{Name: "priority", err: errors.New(`db: missing required field "ModelProvider.priority"`)}
+	}
+	if _, ok := mpc.mutation.CreatedAt(); !ok {
+		return &ValidationError{Name: "created_at", err: errors.New(`db: missing required field "ModelProvider.created_at"`)}
+	}
+	if _, ok := mpc.mutation.UpdatedAt(); !ok {
+		return &ValidationError{Name: "updated_at", err: errors.New(`db: missing required field "ModelProvider.updated_at"`)}
+	}
+	if v, ok := mpc.mutation.ID(); ok {
+		if err := modelprovider.IDValidator(v); err != nil {
+			return &ValidationError{Name: "id", err: fmt.Errorf(`db: validator failed for field "ModelProvider.id": %w`, err)}
+		}
+	}
+	return nil
+}
+
+func (mpc *ModelProviderCreate) sqlSave(ctx context.Context) (*ModelProvider, error) {
+	if err := mpc.check(); err != nil {
+		return nil, err
+	}
+	_node, _spec := mpc.createSpec()
+	if err := sqlgraph.CreateNode(ctx, mpc.driver, _spec); err != nil {
+		if sqlgraph.IsConstraintError(err) {
+			err = &ConstraintError{msg: err.Error(), wrap: err}
+		}
+		return nil, err
+	}
+	if _spec.ID.Value != nil {
+		if id, ok := _spec.ID.Value.(string); ok {
+			_node.ID = id
+		} else {
+			return nil, fmt.Errorf("unexpected ModelProvider.ID type: %T", _spec.ID.Value)
+		}
+	}
+	mpc.mutation.id = &_node.ID
+	mpc.mutation.done = true
+	return _node, nil
+}
+
+func (mpc *ModelProviderCreate) createSpec() (*ModelProvider, *sqlgraph.CreateSpec) {
+	var (
+		_node = &ModelProvider{config: mpc.config}
+		_spec = sqlgraph.NewCreateSpec(modelprovider.Table, sqlgraph.NewFieldSpec(modelprovider.FieldID, field.TypeString))
+	)
+	_spec.OnConflict = mpc.conflict
+	if id, ok := mpc.mutation.ID(); ok {
+		_node.ID = id
+		_spec.ID.Value = id
+	}
+	if value, ok := mpc.mutation.Name(); ok {
+		_spec.SetField(modelprovider.FieldName, field.TypeString, value)
+		_node.Name = value
+	}
+	if value, ok := mpc.mutation.APIBase(); ok {
+		_spec.SetField(modelprovider.FieldAPIBase, field.TypeString, value)
+		_node.APIBase = value
+	}
+	if value, ok := mpc.mutation.Priority(); ok {
+		_spec.SetField(modelprovider.FieldPriority, field.TypeInt, value)
+		_node.Priority = value
+	}
+	if value, ok := mpc.mutation.CreatedAt(); ok {
+		_spec.SetField(modelprovider.FieldCreatedAt, field.TypeTime, value)
+		_node.CreatedAt = value
+	}
+	if value, ok := mpc.mutation.UpdatedAt(); ok {
+		_spec.SetField(modelprovider.FieldUpdatedAt, field.TypeTime, value)
+		_node.UpdatedAt = value
+	}
+	if nodes := mpc.mutation.ModelsIDs(); len(nodes) > 0 {
+		edge := &sqlgraph.EdgeSpec{
+			Rel:     sqlgraph.O2M,
+			Inverse: false,
+			Table:   modelprovider.ModelsTable,
+			Columns: []string{modelprovider.ModelsColumn},
+			Bidi:    false,
+			Target: &sqlgraph.EdgeTarget{
+				IDSpec: sqlgraph.NewFieldSpec(modelprovidermodel.FieldID, field.TypeUUID),
+			},
+		}
+		for _, k := range nodes {
+			edge.Target.Nodes = append(edge.Target.Nodes, k)
+		}
+		_spec.Edges = append(_spec.Edges, edge)
+	}
+	return _node, _spec
+}
+
+// OnConflict allows configuring the `ON CONFLICT` / `ON DUPLICATE KEY` clause
+// of the `INSERT` statement. For example:
+//
+//	client.ModelProvider.Create().
+//		SetName(v).
+//		OnConflict(
+//			// Update the row with the new values
+//			// the was proposed for insertion.
+//			sql.ResolveWithNewValues(),
+//		).
+//		// Override some of the fields with custom
+//		// update values.
+//		Update(func(u *ent.ModelProviderUpsert) {
+//			SetName(v+v).
+//		}).
+//		Exec(ctx)
+func (mpc *ModelProviderCreate) OnConflict(opts ...sql.ConflictOption) *ModelProviderUpsertOne {
+	mpc.conflict = opts
+	return &ModelProviderUpsertOne{
+		create: mpc,
+	}
+}
+
+// OnConflictColumns calls `OnConflict` and configures the columns
+// as conflict target. Using this option is equivalent to using:
+//
+//	client.ModelProvider.Create().
+//		OnConflict(sql.ConflictColumns(columns...)).
+//		Exec(ctx)
+func (mpc *ModelProviderCreate) OnConflictColumns(columns ...string) *ModelProviderUpsertOne {
+	mpc.conflict = append(mpc.conflict, sql.ConflictColumns(columns...))
+	return &ModelProviderUpsertOne{
+		create: mpc,
+	}
+}
+
+type (
+	// ModelProviderUpsertOne is the builder for "upsert"-ing
+	//  one ModelProvider node.
+	ModelProviderUpsertOne struct {
+		create *ModelProviderCreate
+	}
+
+	// ModelProviderUpsert is the "OnConflict" setter.
+	ModelProviderUpsert struct {
+		*sql.UpdateSet
+	}
+)
+
+// SetName sets the "name" field.
+func (u *ModelProviderUpsert) SetName(v string) *ModelProviderUpsert {
+	u.Set(modelprovider.FieldName, v)
+	return u
+}
+
+// UpdateName sets the "name" field to the value that was provided on create.
+func (u *ModelProviderUpsert) UpdateName() *ModelProviderUpsert {
+	u.SetExcluded(modelprovider.FieldName)
+	return u
+}
+
+// SetAPIBase sets the "api_base" field.
+func (u *ModelProviderUpsert) SetAPIBase(v string) *ModelProviderUpsert {
+	u.Set(modelprovider.FieldAPIBase, v)
+	return u
+}
+
+// UpdateAPIBase sets the "api_base" field to the value that was provided on create.
+func (u *ModelProviderUpsert) UpdateAPIBase() *ModelProviderUpsert {
+	u.SetExcluded(modelprovider.FieldAPIBase)
+	return u
+}
+
+// SetPriority sets the "priority" field.
+func (u *ModelProviderUpsert) SetPriority(v int) *ModelProviderUpsert {
+	u.Set(modelprovider.FieldPriority, v)
+	return u
+}
+
+// UpdatePriority sets the "priority" field to the value that was provided on create.
+func (u *ModelProviderUpsert) UpdatePriority() *ModelProviderUpsert {
+	u.SetExcluded(modelprovider.FieldPriority)
+	return u
+}
+
+// AddPriority adds v to the "priority" field.
+func (u *ModelProviderUpsert) AddPriority(v int) *ModelProviderUpsert {
+	u.Add(modelprovider.FieldPriority, v)
+	return u
+}
+
+// SetCreatedAt sets the "created_at" field.
+func (u *ModelProviderUpsert) SetCreatedAt(v time.Time) *ModelProviderUpsert {
+	u.Set(modelprovider.FieldCreatedAt, v)
+	return u
+}
+
+// UpdateCreatedAt sets the "created_at" field to the value that was provided on create.
+func (u *ModelProviderUpsert) UpdateCreatedAt() *ModelProviderUpsert {
+	u.SetExcluded(modelprovider.FieldCreatedAt)
+	return u
+}
+
+// SetUpdatedAt sets the "updated_at" field.
+func (u *ModelProviderUpsert) SetUpdatedAt(v time.Time) *ModelProviderUpsert {
+	u.Set(modelprovider.FieldUpdatedAt, v)
+	return u
+}
+
+// UpdateUpdatedAt sets the "updated_at" field to the value that was provided on create.
+func (u *ModelProviderUpsert) UpdateUpdatedAt() *ModelProviderUpsert {
+	u.SetExcluded(modelprovider.FieldUpdatedAt)
+	return u
+}
+
+// UpdateNewValues updates the mutable fields using the new values that were set on create except the ID field.
+// Using this option is equivalent to using:
+//
+//	client.ModelProvider.Create().
+//		OnConflict(
+//			sql.ResolveWithNewValues(),
+//			sql.ResolveWith(func(u *sql.UpdateSet) {
+//				u.SetIgnore(modelprovider.FieldID)
+//			}),
+//		).
+//		Exec(ctx)
+func (u *ModelProviderUpsertOne) UpdateNewValues() *ModelProviderUpsertOne {
+	u.create.conflict = append(u.create.conflict, sql.ResolveWithNewValues())
+	u.create.conflict = append(u.create.conflict, sql.ResolveWith(func(s *sql.UpdateSet) {
+		if _, exists := u.create.mutation.ID(); exists {
+			s.SetIgnore(modelprovider.FieldID)
+		}
+	}))
+	return u
+}
+
+// Ignore sets each column to itself in case of conflict.
+// Using this option is equivalent to using:
+//
+//	client.ModelProvider.Create().
+//	    OnConflict(sql.ResolveWithIgnore()).
+//	    Exec(ctx)
+func (u *ModelProviderUpsertOne) Ignore() *ModelProviderUpsertOne {
+	u.create.conflict = append(u.create.conflict, sql.ResolveWithIgnore())
+	return u
+}
+
+// DoNothing configures the conflict_action to `DO NOTHING`.
+// Supported only by SQLite and PostgreSQL.
+func (u *ModelProviderUpsertOne) DoNothing() *ModelProviderUpsertOne {
+	u.create.conflict = append(u.create.conflict, sql.DoNothing())
+	return u
+}
+
+// Update allows overriding fields `UPDATE` values. See the ModelProviderCreate.OnConflict
+// documentation for more info.
+func (u *ModelProviderUpsertOne) Update(set func(*ModelProviderUpsert)) *ModelProviderUpsertOne {
+	u.create.conflict = append(u.create.conflict, sql.ResolveWith(func(update *sql.UpdateSet) {
+		set(&ModelProviderUpsert{UpdateSet: update})
+	}))
+	return u
+}
+
+// SetName sets the "name" field.
+func (u *ModelProviderUpsertOne) SetName(v string) *ModelProviderUpsertOne {
+	return u.Update(func(s *ModelProviderUpsert) {
+		s.SetName(v)
+	})
+}
+
+// UpdateName sets the "name" field to the value that was provided on create.
+func (u *ModelProviderUpsertOne) UpdateName() *ModelProviderUpsertOne {
+	return u.Update(func(s *ModelProviderUpsert) {
+		s.UpdateName()
+	})
+}
+
+// SetAPIBase sets the "api_base" field.
+func (u *ModelProviderUpsertOne) SetAPIBase(v string) *ModelProviderUpsertOne {
+	return u.Update(func(s *ModelProviderUpsert) {
+		s.SetAPIBase(v)
+	})
+}
+
+// UpdateAPIBase sets the "api_base" field to the value that was provided on create.
+func (u *ModelProviderUpsertOne) UpdateAPIBase() *ModelProviderUpsertOne {
+	return u.Update(func(s *ModelProviderUpsert) {
+		s.UpdateAPIBase()
+	})
+}
+
+// SetPriority sets the "priority" field.
+func (u *ModelProviderUpsertOne) SetPriority(v int) *ModelProviderUpsertOne {
+	return u.Update(func(s *ModelProviderUpsert) {
+		s.SetPriority(v)
+	})
+}
+
+// AddPriority adds v to the "priority" field.
+func (u *ModelProviderUpsertOne) AddPriority(v int) *ModelProviderUpsertOne {
+	return u.Update(func(s *ModelProviderUpsert) {
+		s.AddPriority(v)
+	})
+}
+
+// UpdatePriority sets the "priority" field to the value that was provided on create.
+func (u *ModelProviderUpsertOne) UpdatePriority() *ModelProviderUpsertOne {
+	return u.Update(func(s *ModelProviderUpsert) {
+		s.UpdatePriority()
+	})
+}
+
+// SetCreatedAt sets the "created_at" field.
+func (u *ModelProviderUpsertOne) SetCreatedAt(v time.Time) *ModelProviderUpsertOne {
+	return u.Update(func(s *ModelProviderUpsert) {
+		s.SetCreatedAt(v)
+	})
+}
+
+// UpdateCreatedAt sets the "created_at" field to the value that was provided on create.
+func (u *ModelProviderUpsertOne) UpdateCreatedAt() *ModelProviderUpsertOne {
+	return u.Update(func(s *ModelProviderUpsert) {
+		s.UpdateCreatedAt()
+	})
+}
+
+// SetUpdatedAt sets the "updated_at" field.
+func (u *ModelProviderUpsertOne) SetUpdatedAt(v time.Time) *ModelProviderUpsertOne {
+	return u.Update(func(s *ModelProviderUpsert) {
+		s.SetUpdatedAt(v)
+	})
+}
+
+// UpdateUpdatedAt sets the "updated_at" field to the value that was provided on create.
+func (u *ModelProviderUpsertOne) UpdateUpdatedAt() *ModelProviderUpsertOne {
+	return u.Update(func(s *ModelProviderUpsert) {
+		s.UpdateUpdatedAt()
+	})
+}
+
+// Exec executes the query.
+func (u *ModelProviderUpsertOne) Exec(ctx context.Context) error {
+	if len(u.create.conflict) == 0 {
+		return errors.New("db: missing options for ModelProviderCreate.OnConflict")
+	}
+	return u.create.Exec(ctx)
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (u *ModelProviderUpsertOne) ExecX(ctx context.Context) {
+	if err := u.create.Exec(ctx); err != nil {
+		panic(err)
+	}
+}
+
+// Exec executes the UPSERT query and returns the inserted/updated ID.
+func (u *ModelProviderUpsertOne) ID(ctx context.Context) (id string, err error) {
+	if u.create.driver.Dialect() == dialect.MySQL {
+		// In case of "ON CONFLICT", there is no way to get back non-numeric ID
+		// fields from the database since MySQL does not support the RETURNING clause.
+		return id, errors.New("db: ModelProviderUpsertOne.ID is not supported by MySQL driver. Use ModelProviderUpsertOne.Exec instead")
+	}
+	node, err := u.create.Save(ctx)
+	if err != nil {
+		return id, err
+	}
+	return node.ID, nil
+}
+
+// IDX is like ID, but panics if an error occurs.
+func (u *ModelProviderUpsertOne) IDX(ctx context.Context) string {
+	id, err := u.ID(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return id
+}
+
+// ModelProviderCreateBulk is the builder for creating many ModelProvider entities in bulk.
+type ModelProviderCreateBulk struct {
+	config
+	err      error
+	builders []*ModelProviderCreate
+	conflict []sql.ConflictOption
+}
+
+// Save creates the ModelProvider entities in the database.
+func (mpcb *ModelProviderCreateBulk) Save(ctx context.Context) ([]*ModelProvider, error) {
+	if mpcb.err != nil {
+		return nil, mpcb.err
+	}
+	specs := make([]*sqlgraph.CreateSpec, len(mpcb.builders))
+	nodes := make([]*ModelProvider, len(mpcb.builders))
+	mutators := make([]Mutator, len(mpcb.builders))
+	for i := range mpcb.builders {
+		func(i int, root context.Context) {
+			builder := mpcb.builders[i]
+			builder.defaults()
+			var mut Mutator = MutateFunc(func(ctx context.Context, m Mutation) (Value, error) {
+				mutation, ok := m.(*ModelProviderMutation)
+				if !ok {
+					return nil, fmt.Errorf("unexpected mutation type %T", m)
+				}
+				if err := builder.check(); err != nil {
+					return nil, err
+				}
+				builder.mutation = mutation
+				var err error
+				nodes[i], specs[i] = builder.createSpec()
+				if i < len(mutators)-1 {
+					_, err = mutators[i+1].Mutate(root, mpcb.builders[i+1].mutation)
+				} else {
+					spec := &sqlgraph.BatchCreateSpec{Nodes: specs}
+					spec.OnConflict = mpcb.conflict
+					// Invoke the actual operation on the latest mutation in the chain.
+					if err = sqlgraph.BatchCreate(ctx, mpcb.driver, spec); err != nil {
+						if sqlgraph.IsConstraintError(err) {
+							err = &ConstraintError{msg: err.Error(), wrap: err}
+						}
+					}
+				}
+				if err != nil {
+					return nil, err
+				}
+				mutation.id = &nodes[i].ID
+				mutation.done = true
+				return nodes[i], nil
+			})
+			for i := len(builder.hooks) - 1; i >= 0; i-- {
+				mut = builder.hooks[i](mut)
+			}
+			mutators[i] = mut
+		}(i, ctx)
+	}
+	if len(mutators) > 0 {
+		if _, err := mutators[0].Mutate(ctx, mpcb.builders[0].mutation); err != nil {
+			return nil, err
+		}
+	}
+	return nodes, nil
+}
+
+// SaveX is like Save, but panics if an error occurs.
+func (mpcb *ModelProviderCreateBulk) SaveX(ctx context.Context) []*ModelProvider {
+	v, err := mpcb.Save(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return v
+}
+
+// Exec executes the query.
+func (mpcb *ModelProviderCreateBulk) Exec(ctx context.Context) error {
+	_, err := mpcb.Save(ctx)
+	return err
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (mpcb *ModelProviderCreateBulk) ExecX(ctx context.Context) {
+	if err := mpcb.Exec(ctx); err != nil {
+		panic(err)
+	}
+}
+
+// OnConflict allows configuring the `ON CONFLICT` / `ON DUPLICATE KEY` clause
+// of the `INSERT` statement. For example:
+//
+//	client.ModelProvider.CreateBulk(builders...).
+//		OnConflict(
+//			// Update the row with the new values
+//			// the was proposed for insertion.
+//			sql.ResolveWithNewValues(),
+//		).
+//		// Override some of the fields with custom
+//		// update values.
+//		Update(func(u *ent.ModelProviderUpsert) {
+//			SetName(v+v).
+//		}).
+//		Exec(ctx)
+func (mpcb *ModelProviderCreateBulk) OnConflict(opts ...sql.ConflictOption) *ModelProviderUpsertBulk {
+	mpcb.conflict = opts
+	return &ModelProviderUpsertBulk{
+		create: mpcb,
+	}
+}
+
+// OnConflictColumns calls `OnConflict` and configures the columns
+// as conflict target. Using this option is equivalent to using:
+//
+//	client.ModelProvider.Create().
+//		OnConflict(sql.ConflictColumns(columns...)).
+//		Exec(ctx)
+func (mpcb *ModelProviderCreateBulk) OnConflictColumns(columns ...string) *ModelProviderUpsertBulk {
+	mpcb.conflict = append(mpcb.conflict, sql.ConflictColumns(columns...))
+	return &ModelProviderUpsertBulk{
+		create: mpcb,
+	}
+}
+
+// ModelProviderUpsertBulk is the builder for "upsert"-ing
+// a bulk of ModelProvider nodes.
+type ModelProviderUpsertBulk struct {
+	create *ModelProviderCreateBulk
+}
+
+// UpdateNewValues updates the mutable fields using the new values that
+// were set on create. Using this option is equivalent to using:
+//
+//	client.ModelProvider.Create().
+//		OnConflict(
+//			sql.ResolveWithNewValues(),
+//			sql.ResolveWith(func(u *sql.UpdateSet) {
+//				u.SetIgnore(modelprovider.FieldID)
+//			}),
+//		).
+//		Exec(ctx)
+func (u *ModelProviderUpsertBulk) UpdateNewValues() *ModelProviderUpsertBulk {
+	u.create.conflict = append(u.create.conflict, sql.ResolveWithNewValues())
+	u.create.conflict = append(u.create.conflict, sql.ResolveWith(func(s *sql.UpdateSet) {
+		for _, b := range u.create.builders {
+			if _, exists := b.mutation.ID(); exists {
+				s.SetIgnore(modelprovider.FieldID)
+			}
+		}
+	}))
+	return u
+}
+
+// Ignore sets each column to itself in case of conflict.
+// Using this option is equivalent to using:
+//
+//	client.ModelProvider.Create().
+//		OnConflict(sql.ResolveWithIgnore()).
+//		Exec(ctx)
+func (u *ModelProviderUpsertBulk) Ignore() *ModelProviderUpsertBulk {
+	u.create.conflict = append(u.create.conflict, sql.ResolveWithIgnore())
+	return u
+}
+
+// DoNothing configures the conflict_action to `DO NOTHING`.
+// Supported only by SQLite and PostgreSQL.
+func (u *ModelProviderUpsertBulk) DoNothing() *ModelProviderUpsertBulk {
+	u.create.conflict = append(u.create.conflict, sql.DoNothing())
+	return u
+}
+
+// Update allows overriding fields `UPDATE` values. See the ModelProviderCreateBulk.OnConflict
+// documentation for more info.
+func (u *ModelProviderUpsertBulk) Update(set func(*ModelProviderUpsert)) *ModelProviderUpsertBulk {
+	u.create.conflict = append(u.create.conflict, sql.ResolveWith(func(update *sql.UpdateSet) {
+		set(&ModelProviderUpsert{UpdateSet: update})
+	}))
+	return u
+}
+
+// SetName sets the "name" field.
+func (u *ModelProviderUpsertBulk) SetName(v string) *ModelProviderUpsertBulk {
+	return u.Update(func(s *ModelProviderUpsert) {
+		s.SetName(v)
+	})
+}
+
+// UpdateName sets the "name" field to the value that was provided on create.
+func (u *ModelProviderUpsertBulk) UpdateName() *ModelProviderUpsertBulk {
+	return u.Update(func(s *ModelProviderUpsert) {
+		s.UpdateName()
+	})
+}
+
+// SetAPIBase sets the "api_base" field.
+func (u *ModelProviderUpsertBulk) SetAPIBase(v string) *ModelProviderUpsertBulk {
+	return u.Update(func(s *ModelProviderUpsert) {
+		s.SetAPIBase(v)
+	})
+}
+
+// UpdateAPIBase sets the "api_base" field to the value that was provided on create.
+func (u *ModelProviderUpsertBulk) UpdateAPIBase() *ModelProviderUpsertBulk {
+	return u.Update(func(s *ModelProviderUpsert) {
+		s.UpdateAPIBase()
+	})
+}
+
+// SetPriority sets the "priority" field.
+func (u *ModelProviderUpsertBulk) SetPriority(v int) *ModelProviderUpsertBulk {
+	return u.Update(func(s *ModelProviderUpsert) {
+		s.SetPriority(v)
+	})
+}
+
+// AddPriority adds v to the "priority" field.
+func (u *ModelProviderUpsertBulk) AddPriority(v int) *ModelProviderUpsertBulk {
+	return u.Update(func(s *ModelProviderUpsert) {
+		s.AddPriority(v)
+	})
+}
+
+// UpdatePriority sets the "priority" field to the value that was provided on create.
+func (u *ModelProviderUpsertBulk) UpdatePriority() *ModelProviderUpsertBulk {
+	return u.Update(func(s *ModelProviderUpsert) {
+		s.UpdatePriority()
+	})
+}
+
+// SetCreatedAt sets the "created_at" field.
+func (u *ModelProviderUpsertBulk) SetCreatedAt(v time.Time) *ModelProviderUpsertBulk {
+	return u.Update(func(s *ModelProviderUpsert) {
+		s.SetCreatedAt(v)
+	})
+}
+
+// UpdateCreatedAt sets the "created_at" field to the value that was provided on create.
+func (u *ModelProviderUpsertBulk) UpdateCreatedAt() *ModelProviderUpsertBulk {
+	return u.Update(func(s *ModelProviderUpsert) {
+		s.UpdateCreatedAt()
+	})
+}
+
+// SetUpdatedAt sets the "updated_at" field.
+func (u *ModelProviderUpsertBulk) SetUpdatedAt(v time.Time) *ModelProviderUpsertBulk {
+	return u.Update(func(s *ModelProviderUpsert) {
+		s.SetUpdatedAt(v)
+	})
+}
+
+// UpdateUpdatedAt sets the "updated_at" field to the value that was provided on create.
+func (u *ModelProviderUpsertBulk) UpdateUpdatedAt() *ModelProviderUpsertBulk {
+	return u.Update(func(s *ModelProviderUpsert) {
+		s.UpdateUpdatedAt()
+	})
+}
+
+// Exec executes the query.
+func (u *ModelProviderUpsertBulk) Exec(ctx context.Context) error {
+	if u.create.err != nil {
+		return u.create.err
+	}
+	for i, b := range u.create.builders {
+		if len(b.conflict) != 0 {
+			return fmt.Errorf("db: OnConflict was set for builder %d. Set it on the ModelProviderCreateBulk instead", i)
+		}
+	}
+	if len(u.create.conflict) == 0 {
+		return errors.New("db: missing options for ModelProviderCreateBulk.OnConflict")
+	}
+	return u.create.Exec(ctx)
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (u *ModelProviderUpsertBulk) ExecX(ctx context.Context) {
+	if err := u.create.Exec(ctx); err != nil {
+		panic(err)
+	}
+}

backend/db/modelprovider_delete.go

@@ -0,0 +1,88 @@
+// Code generated by ent, DO NOT EDIT.
+
+package db
+
+import (
+	"context"
+
+	"entgo.io/ent/dialect/sql"
+	"entgo.io/ent/dialect/sql/sqlgraph"
+	"entgo.io/ent/schema/field"
+	"github.com/chaitin/MonkeyCode/backend/db/modelprovider"
+	"github.com/chaitin/MonkeyCode/backend/db/predicate"
+)
+
+// ModelProviderDelete is the builder for deleting a ModelProvider entity.
+type ModelProviderDelete struct {
+	config
+	hooks    []Hook
+	mutation *ModelProviderMutation
+}
+
+// Where appends a list predicates to the ModelProviderDelete builder.
+func (mpd *ModelProviderDelete) Where(ps ...predicate.ModelProvider) *ModelProviderDelete {
+	mpd.mutation.Where(ps...)
+	return mpd
+}
+
+// Exec executes the deletion query and returns how many vertices were deleted.
+func (mpd *ModelProviderDelete) Exec(ctx context.Context) (int, error) {
+	return withHooks(ctx, mpd.sqlExec, mpd.mutation, mpd.hooks)
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (mpd *ModelProviderDelete) ExecX(ctx context.Context) int {
+	n, err := mpd.Exec(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return n
+}
+
+func (mpd *ModelProviderDelete) sqlExec(ctx context.Context) (int, error) {
+	_spec := sqlgraph.NewDeleteSpec(modelprovider.Table, sqlgraph.NewFieldSpec(modelprovider.FieldID, field.TypeString))
+	if ps := mpd.mutation.predicates; len(ps) > 0 {
+		_spec.Predicate = func(selector *sql.Selector) {
+			for i := range ps {
+				ps[i](selector)
+			}
+		}
+	}
+	affected, err := sqlgraph.DeleteNodes(ctx, mpd.driver, _spec)
+	if err != nil && sqlgraph.IsConstraintError(err) {
+		err = &ConstraintError{msg: err.Error(), wrap: err}
+	}
+	mpd.mutation.done = true
+	return affected, err
+}
+
+// ModelProviderDeleteOne is the builder for deleting a single ModelProvider entity.
+type ModelProviderDeleteOne struct {
+	mpd *ModelProviderDelete
+}
+
+// Where appends a list predicates to the ModelProviderDelete builder.
+func (mpdo *ModelProviderDeleteOne) Where(ps ...predicate.ModelProvider) *ModelProviderDeleteOne {
+	mpdo.mpd.mutation.Where(ps...)
+	return mpdo
+}
+
+// Exec executes the deletion query.
+func (mpdo *ModelProviderDeleteOne) Exec(ctx context.Context) error {
+	n, err := mpdo.mpd.Exec(ctx)
+	switch {
+	case err != nil:
+		return err
+	case n == 0:
+		return &NotFoundError{modelprovider.Label}
+	default:
+		return nil
+	}
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (mpdo *ModelProviderDeleteOne) ExecX(ctx context.Context) {
+	if err := mpdo.Exec(ctx); err != nil {
+		panic(err)
+	}
+}

backend/db/modelprovider_query.go

@@ -0,0 +1,656 @@
+// Code generated by ent, DO NOT EDIT.
+
+package db
+
+import (
+	"context"
+	"database/sql/driver"
+	"fmt"
+	"math"
+
+	"entgo.io/ent"
+	"entgo.io/ent/dialect"
+	"entgo.io/ent/dialect/sql"
+	"entgo.io/ent/dialect/sql/sqlgraph"
+	"entgo.io/ent/schema/field"
+	"github.com/chaitin/MonkeyCode/backend/db/modelprovider"
+	"github.com/chaitin/MonkeyCode/backend/db/modelprovidermodel"
+	"github.com/chaitin/MonkeyCode/backend/db/predicate"
+)
+
+// ModelProviderQuery is the builder for querying ModelProvider entities.
+type ModelProviderQuery struct {
+	config
+	ctx        *QueryContext
+	order      []modelprovider.OrderOption
+	inters     []Interceptor
+	predicates []predicate.ModelProvider
+	withModels *ModelProviderModelQuery
+	modifiers  []func(*sql.Selector)
+	// intermediate query (i.e. traversal path).
+	sql  *sql.Selector
+	path func(context.Context) (*sql.Selector, error)
+}
+
+// Where adds a new predicate for the ModelProviderQuery builder.
+func (mpq *ModelProviderQuery) Where(ps ...predicate.ModelProvider) *ModelProviderQuery {
+	mpq.predicates = append(mpq.predicates, ps...)
+	return mpq
+}
+
+// Limit the number of records to be returned by this query.
+func (mpq *ModelProviderQuery) Limit(limit int) *ModelProviderQuery {
+	mpq.ctx.Limit = &limit
+	return mpq
+}
+
+// Offset to start from.
+func (mpq *ModelProviderQuery) Offset(offset int) *ModelProviderQuery {
+	mpq.ctx.Offset = &offset
+	return mpq
+}
+
+// Unique configures the query builder to filter duplicate records on query.
+// By default, unique is set to true, and can be disabled using this method.
+func (mpq *ModelProviderQuery) Unique(unique bool) *ModelProviderQuery {
+	mpq.ctx.Unique = &unique
+	return mpq
+}
+
+// Order specifies how the records should be ordered.
+func (mpq *ModelProviderQuery) Order(o ...modelprovider.OrderOption) *ModelProviderQuery {
+	mpq.order = append(mpq.order, o...)
+	return mpq
+}
+
+// QueryModels chains the current query on the "models" edge.
+func (mpq *ModelProviderQuery) QueryModels() *ModelProviderModelQuery {
+	query := (&ModelProviderModelClient{config: mpq.config}).Query()
+	query.path = func(ctx context.Context) (fromU *sql.Selector, err error) {
+		if err := mpq.prepareQuery(ctx); err != nil {
+			return nil, err
+		}
+		selector := mpq.sqlQuery(ctx)
+		if err := selector.Err(); err != nil {
+			return nil, err
+		}
+		step := sqlgraph.NewStep(
+			sqlgraph.From(modelprovider.Table, modelprovider.FieldID, selector),
+			sqlgraph.To(modelprovidermodel.Table, modelprovidermodel.FieldID),
+			sqlgraph.Edge(sqlgraph.O2M, false, modelprovider.ModelsTable, modelprovider.ModelsColumn),
+		)
+		fromU = sqlgraph.SetNeighbors(mpq.driver.Dialect(), step)
+		return fromU, nil
+	}
+	return query
+}
+
+// First returns the first ModelProvider entity from the query.
+// Returns a *NotFoundError when no ModelProvider was found.
+func (mpq *ModelProviderQuery) First(ctx context.Context) (*ModelProvider, error) {
+	nodes, err := mpq.Limit(1).All(setContextOp(ctx, mpq.ctx, ent.OpQueryFirst))
+	if err != nil {
+		return nil, err
+	}
+	if len(nodes) == 0 {
+		return nil, &NotFoundError{modelprovider.Label}
+	}
+	return nodes[0], nil
+}
+
+// FirstX is like First, but panics if an error occurs.
+func (mpq *ModelProviderQuery) FirstX(ctx context.Context) *ModelProvider {
+	node, err := mpq.First(ctx)
+	if err != nil && !IsNotFound(err) {
+		panic(err)
+	}
+	return node
+}
+
+// FirstID returns the first ModelProvider ID from the query.
+// Returns a *NotFoundError when no ModelProvider ID was found.
+func (mpq *ModelProviderQuery) FirstID(ctx context.Context) (id string, err error) {
+	var ids []string
+	if ids, err = mpq.Limit(1).IDs(setContextOp(ctx, mpq.ctx, ent.OpQueryFirstID)); err != nil {
+		return
+	}
+	if len(ids) == 0 {
+		err = &NotFoundError{modelprovider.Label}
+		return
+	}
+	return ids[0], nil
+}
+
+// FirstIDX is like FirstID, but panics if an error occurs.
+func (mpq *ModelProviderQuery) FirstIDX(ctx context.Context) string {
+	id, err := mpq.FirstID(ctx)
+	if err != nil && !IsNotFound(err) {
+		panic(err)
+	}
+	return id
+}
+
+// Only returns a single ModelProvider entity found by the query, ensuring it only returns one.
+// Returns a *NotSingularError when more than one ModelProvider entity is found.
+// Returns a *NotFoundError when no ModelProvider entities are found.
+func (mpq *ModelProviderQuery) Only(ctx context.Context) (*ModelProvider, error) {
+	nodes, err := mpq.Limit(2).All(setContextOp(ctx, mpq.ctx, ent.OpQueryOnly))
+	if err != nil {
+		return nil, err
+	}
+	switch len(nodes) {
+	case 1:
+		return nodes[0], nil
+	case 0:
+		return nil, &NotFoundError{modelprovider.Label}
+	default:
+		return nil, &NotSingularError{modelprovider.Label}
+	}
+}
+
+// OnlyX is like Only, but panics if an error occurs.
+func (mpq *ModelProviderQuery) OnlyX(ctx context.Context) *ModelProvider {
+	node, err := mpq.Only(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return node
+}
+
+// OnlyID is like Only, but returns the only ModelProvider ID in the query.
+// Returns a *NotSingularError when more than one ModelProvider ID is found.
+// Returns a *NotFoundError when no entities are found.
+func (mpq *ModelProviderQuery) OnlyID(ctx context.Context) (id string, err error) {
+	var ids []string
+	if ids, err = mpq.Limit(2).IDs(setContextOp(ctx, mpq.ctx, ent.OpQueryOnlyID)); err != nil {
+		return
+	}
+	switch len(ids) {
+	case 1:
+		id = ids[0]
+	case 0:
+		err = &NotFoundError{modelprovider.Label}
+	default:
+		err = &NotSingularError{modelprovider.Label}
+	}
+	return
+}
+
+// OnlyIDX is like OnlyID, but panics if an error occurs.
+func (mpq *ModelProviderQuery) OnlyIDX(ctx context.Context) string {
+	id, err := mpq.OnlyID(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return id
+}
+
+// All executes the query and returns a list of ModelProviders.
+func (mpq *ModelProviderQuery) All(ctx context.Context) ([]*ModelProvider, error) {
+	ctx = setContextOp(ctx, mpq.ctx, ent.OpQueryAll)
+	if err := mpq.prepareQuery(ctx); err != nil {
+		return nil, err
+	}
+	qr := querierAll[[]*ModelProvider, *ModelProviderQuery]()
+	return withInterceptors[[]*ModelProvider](ctx, mpq, qr, mpq.inters)
+}
+
+// AllX is like All, but panics if an error occurs.
+func (mpq *ModelProviderQuery) AllX(ctx context.Context) []*ModelProvider {
+	nodes, err := mpq.All(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return nodes
+}
+
+// IDs executes the query and returns a list of ModelProvider IDs.
+func (mpq *ModelProviderQuery) IDs(ctx context.Context) (ids []string, err error) {
+	if mpq.ctx.Unique == nil && mpq.path != nil {
+		mpq.Unique(true)
+	}
+	ctx = setContextOp(ctx, mpq.ctx, ent.OpQueryIDs)
+	if err = mpq.Select(modelprovider.FieldID).Scan(ctx, &ids); err != nil {
+		return nil, err
+	}
+	return ids, nil
+}
+
+// IDsX is like IDs, but panics if an error occurs.
+func (mpq *ModelProviderQuery) IDsX(ctx context.Context) []string {
+	ids, err := mpq.IDs(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return ids
+}
+
+// Count returns the count of the given query.
+func (mpq *ModelProviderQuery) Count(ctx context.Context) (int, error) {
+	ctx = setContextOp(ctx, mpq.ctx, ent.OpQueryCount)
+	if err := mpq.prepareQuery(ctx); err != nil {
+		return 0, err
+	}
+	return withInterceptors[int](ctx, mpq, querierCount[*ModelProviderQuery](), mpq.inters)
+}
+
+// CountX is like Count, but panics if an error occurs.
+func (mpq *ModelProviderQuery) CountX(ctx context.Context) int {
+	count, err := mpq.Count(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return count
+}
+
+// Exist returns true if the query has elements in the graph.
+func (mpq *ModelProviderQuery) Exist(ctx context.Context) (bool, error) {
+	ctx = setContextOp(ctx, mpq.ctx, ent.OpQueryExist)
+	switch _, err := mpq.FirstID(ctx); {
+	case IsNotFound(err):
+		return false, nil
+	case err != nil:
+		return false, fmt.Errorf("db: check existence: %w", err)
+	default:
+		return true, nil
+	}
+}
+
+// ExistX is like Exist, but panics if an error occurs.
+func (mpq *ModelProviderQuery) ExistX(ctx context.Context) bool {
+	exist, err := mpq.Exist(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return exist
+}
+
+// Clone returns a duplicate of the ModelProviderQuery builder, including all associated steps. It can be
+// used to prepare common query builders and use them differently after the clone is made.
+func (mpq *ModelProviderQuery) Clone() *ModelProviderQuery {
+	if mpq == nil {
+		return nil
+	}
+	return &ModelProviderQuery{
+		config:     mpq.config,
+		ctx:        mpq.ctx.Clone(),
+		order:      append([]modelprovider.OrderOption{}, mpq.order...),
+		inters:     append([]Interceptor{}, mpq.inters...),
+		predicates: append([]predicate.ModelProvider{}, mpq.predicates...),
+		withModels: mpq.withModels.Clone(),
+		// clone intermediate query.
+		sql:       mpq.sql.Clone(),
+		path:      mpq.path,
+		modifiers: append([]func(*sql.Selector){}, mpq.modifiers...),
+	}
+}
+
+// WithModels tells the query-builder to eager-load the nodes that are connected to
+// the "models" edge. The optional arguments are used to configure the query builder of the edge.
+func (mpq *ModelProviderQuery) WithModels(opts ...func(*ModelProviderModelQuery)) *ModelProviderQuery {
+	query := (&ModelProviderModelClient{config: mpq.config}).Query()
+	for _, opt := range opts {
+		opt(query)
+	}
+	mpq.withModels = query
+	return mpq
+}
+
+// GroupBy is used to group vertices by one or more fields/columns.
+// It is often used with aggregate functions, like: count, max, mean, min, sum.
+//
+// Example:
+//
+//	var v []struct {
+//		Name string `json:"name,omitempty"`
+//		Count int `json:"count,omitempty"`
+//	}
+//
+//	client.ModelProvider.Query().
+//		GroupBy(modelprovider.FieldName).
+//		Aggregate(db.Count()).
+//		Scan(ctx, &v)
+func (mpq *ModelProviderQuery) GroupBy(field string, fields ...string) *ModelProviderGroupBy {
+	mpq.ctx.Fields = append([]string{field}, fields...)
+	grbuild := &ModelProviderGroupBy{build: mpq}
+	grbuild.flds = &mpq.ctx.Fields
+	grbuild.label = modelprovider.Label
+	grbuild.scan = grbuild.Scan
+	return grbuild
+}
+
+// Select allows the selection one or more fields/columns for the given query,
+// instead of selecting all fields in the entity.
+//
+// Example:
+//
+//	var v []struct {
+//		Name string `json:"name,omitempty"`
+//	}
+//
+//	client.ModelProvider.Query().
+//		Select(modelprovider.FieldName).
+//		Scan(ctx, &v)
+func (mpq *ModelProviderQuery) Select(fields ...string) *ModelProviderSelect {
+	mpq.ctx.Fields = append(mpq.ctx.Fields, fields...)
+	sbuild := &ModelProviderSelect{ModelProviderQuery: mpq}
+	sbuild.label = modelprovider.Label
+	sbuild.flds, sbuild.scan = &mpq.ctx.Fields, sbuild.Scan
+	return sbuild
+}
+
+// Aggregate returns a ModelProviderSelect configured with the given aggregations.
+func (mpq *ModelProviderQuery) Aggregate(fns ...AggregateFunc) *ModelProviderSelect {
+	return mpq.Select().Aggregate(fns...)
+}
+
+func (mpq *ModelProviderQuery) prepareQuery(ctx context.Context) error {
+	for _, inter := range mpq.inters {
+		if inter == nil {
+			return fmt.Errorf("db: uninitialized interceptor (forgotten import db/runtime?)")
+		}
+		if trv, ok := inter.(Traverser); ok {
+			if err := trv.Traverse(ctx, mpq); err != nil {
+				return err
+			}
+		}
+	}
+	for _, f := range mpq.ctx.Fields {
+		if !modelprovider.ValidColumn(f) {
+			return &ValidationError{Name: f, err: fmt.Errorf("db: invalid field %q for query", f)}
+		}
+	}
+	if mpq.path != nil {
+		prev, err := mpq.path(ctx)
+		if err != nil {
+			return err
+		}
+		mpq.sql = prev
+	}
+	return nil
+}
+
+func (mpq *ModelProviderQuery) sqlAll(ctx context.Context, hooks ...queryHook) ([]*ModelProvider, error) {
+	var (
+		nodes       = []*ModelProvider{}
+		_spec       = mpq.querySpec()
+		loadedTypes = [1]bool{
+			mpq.withModels != nil,
+		}
+	)
+	_spec.ScanValues = func(columns []string) ([]any, error) {
+		return (*ModelProvider).scanValues(nil, columns)
+	}
+	_spec.Assign = func(columns []string, values []any) error {
+		node := &ModelProvider{config: mpq.config}
+		nodes = append(nodes, node)
+		node.Edges.loadedTypes = loadedTypes
+		return node.assignValues(columns, values)
+	}
+	if len(mpq.modifiers) > 0 {
+		_spec.Modifiers = mpq.modifiers
+	}
+	for i := range hooks {
+		hooks[i](ctx, _spec)
+	}
+	if err := sqlgraph.QueryNodes(ctx, mpq.driver, _spec); err != nil {
+		return nil, err
+	}
+	if len(nodes) == 0 {
+		return nodes, nil
+	}
+	if query := mpq.withModels; query != nil {
+		if err := mpq.loadModels(ctx, query, nodes,
+			func(n *ModelProvider) { n.Edges.Models = []*ModelProviderModel{} },
+			func(n *ModelProvider, e *ModelProviderModel) { n.Edges.Models = append(n.Edges.Models, e) }); err != nil {
+			return nil, err
+		}
+	}
+	return nodes, nil
+}
+
+func (mpq *ModelProviderQuery) loadModels(ctx context.Context, query *ModelProviderModelQuery, nodes []*ModelProvider, init func(*ModelProvider), assign func(*ModelProvider, *ModelProviderModel)) error {
+	fks := make([]driver.Value, 0, len(nodes))
+	nodeids := make(map[string]*ModelProvider)
+	for i := range nodes {
+		fks = append(fks, nodes[i].ID)
+		nodeids[nodes[i].ID] = nodes[i]
+		if init != nil {
+			init(nodes[i])
+		}
+	}
+	if len(query.ctx.Fields) > 0 {
+		query.ctx.AppendFieldOnce(modelprovidermodel.FieldProviderID)
+	}
+	query.Where(predicate.ModelProviderModel(func(s *sql.Selector) {
+		s.Where(sql.InValues(s.C(modelprovider.ModelsColumn), fks...))
+	}))
+	neighbors, err := query.All(ctx)
+	if err != nil {
+		return err
+	}
+	for _, n := range neighbors {
+		fk := n.ProviderID
+		node, ok := nodeids[fk]
+		if !ok {
+			return fmt.Errorf(`unexpected referenced foreign-key "provider_id" returned %v for node %v`, fk, n.ID)
+		}
+		assign(node, n)
+	}
+	return nil
+}
+
+func (mpq *ModelProviderQuery) sqlCount(ctx context.Context) (int, error) {
+	_spec := mpq.querySpec()
+	if len(mpq.modifiers) > 0 {
+		_spec.Modifiers = mpq.modifiers
+	}
+	_spec.Node.Columns = mpq.ctx.Fields
+	if len(mpq.ctx.Fields) > 0 {
+		_spec.Unique = mpq.ctx.Unique != nil && *mpq.ctx.Unique
+	}
+	return sqlgraph.CountNodes(ctx, mpq.driver, _spec)
+}
+
+func (mpq *ModelProviderQuery) querySpec() *sqlgraph.QuerySpec {
+	_spec := sqlgraph.NewQuerySpec(modelprovider.Table, modelprovider.Columns, sqlgraph.NewFieldSpec(modelprovider.FieldID, field.TypeString))
+	_spec.From = mpq.sql
+	if unique := mpq.ctx.Unique; unique != nil {
+		_spec.Unique = *unique
+	} else if mpq.path != nil {
+		_spec.Unique = true
+	}
+	if fields := mpq.ctx.Fields; len(fields) > 0 {
+		_spec.Node.Columns = make([]string, 0, len(fields))
+		_spec.Node.Columns = append(_spec.Node.Columns, modelprovider.FieldID)
+		for i := range fields {
+			if fields[i] != modelprovider.FieldID {
+				_spec.Node.Columns = append(_spec.Node.Columns, fields[i])
+			}
+		}
+	}
+	if ps := mpq.predicates; len(ps) > 0 {
+		_spec.Predicate = func(selector *sql.Selector) {
+			for i := range ps {
+				ps[i](selector)
+			}
+		}
+	}
+	if limit := mpq.ctx.Limit; limit != nil {
+		_spec.Limit = *limit
+	}
+	if offset := mpq.ctx.Offset; offset != nil {
+		_spec.Offset = *offset
+	}
+	if ps := mpq.order; len(ps) > 0 {
+		_spec.Order = func(selector *sql.Selector) {
+			for i := range ps {
+				ps[i](selector)
+			}
+		}
+	}
+	return _spec
+}
+
+func (mpq *ModelProviderQuery) sqlQuery(ctx context.Context) *sql.Selector {
+	builder := sql.Dialect(mpq.driver.Dialect())
+	t1 := builder.Table(modelprovider.Table)
+	columns := mpq.ctx.Fields
+	if len(columns) == 0 {
+		columns = modelprovider.Columns
+	}
+	selector := builder.Select(t1.Columns(columns...)...).From(t1)
+	if mpq.sql != nil {
+		selector = mpq.sql
+		selector.Select(selector.Columns(columns...)...)
+	}
+	if mpq.ctx.Unique != nil && *mpq.ctx.Unique {
+		selector.Distinct()
+	}
+	for _, m := range mpq.modifiers {
+		m(selector)
+	}
+	for _, p := range mpq.predicates {
+		p(selector)
+	}
+	for _, p := range mpq.order {
+		p(selector)
+	}
+	if offset := mpq.ctx.Offset; offset != nil {
+		// limit is mandatory for offset clause. We start
+		// with default value, and override it below if needed.
+		selector.Offset(*offset).Limit(math.MaxInt32)
+	}
+	if limit := mpq.ctx.Limit; limit != nil {
+		selector.Limit(*limit)
+	}
+	return selector
+}
+
+// ForUpdate locks the selected rows against concurrent updates, and prevent them from being
+// updated, deleted or "selected ... for update" by other sessions, until the transaction is
+// either committed or rolled-back.
+func (mpq *ModelProviderQuery) ForUpdate(opts ...sql.LockOption) *ModelProviderQuery {
+	if mpq.driver.Dialect() == dialect.Postgres {
+		mpq.Unique(false)
+	}
+	mpq.modifiers = append(mpq.modifiers, func(s *sql.Selector) {
+		s.ForUpdate(opts...)
+	})
+	return mpq
+}
+
+// ForShare behaves similarly to ForUpdate, except that it acquires a shared mode lock
+// on any rows that are read. Other sessions can read the rows, but cannot modify them
+// until your transaction commits.
+func (mpq *ModelProviderQuery) ForShare(opts ...sql.LockOption) *ModelProviderQuery {
+	if mpq.driver.Dialect() == dialect.Postgres {
+		mpq.Unique(false)
+	}
+	mpq.modifiers = append(mpq.modifiers, func(s *sql.Selector) {
+		s.ForShare(opts...)
+	})
+	return mpq
+}
+
+// Modify adds a query modifier for attaching custom logic to queries.
+func (mpq *ModelProviderQuery) Modify(modifiers ...func(s *sql.Selector)) *ModelProviderSelect {
+	mpq.modifiers = append(mpq.modifiers, modifiers...)
+	return mpq.Select()
+}
+
+// ModelProviderGroupBy is the group-by builder for ModelProvider entities.
+type ModelProviderGroupBy struct {
+	selector
+	build *ModelProviderQuery
+}
+
+// Aggregate adds the given aggregation functions to the group-by query.
+func (mpgb *ModelProviderGroupBy) Aggregate(fns ...AggregateFunc) *ModelProviderGroupBy {
+	mpgb.fns = append(mpgb.fns, fns...)
+	return mpgb
+}
+
+// Scan applies the selector query and scans the result into the given value.
+func (mpgb *ModelProviderGroupBy) Scan(ctx context.Context, v any) error {
+	ctx = setContextOp(ctx, mpgb.build.ctx, ent.OpQueryGroupBy)
+	if err := mpgb.build.prepareQuery(ctx); err != nil {
+		return err
+	}
+	return scanWithInterceptors[*ModelProviderQuery, *ModelProviderGroupBy](ctx, mpgb.build, mpgb, mpgb.build.inters, v)
+}
+
+func (mpgb *ModelProviderGroupBy) sqlScan(ctx context.Context, root *ModelProviderQuery, v any) error {
+	selector := root.sqlQuery(ctx).Select()
+	aggregation := make([]string, 0, len(mpgb.fns))
+	for _, fn := range mpgb.fns {
+		aggregation = append(aggregation, fn(selector))
+	}
+	if len(selector.SelectedColumns()) == 0 {
+		columns := make([]string, 0, len(*mpgb.flds)+len(mpgb.fns))
+		for _, f := range *mpgb.flds {
+			columns = append(columns, selector.C(f))
+		}
+		columns = append(columns, aggregation...)
+		selector.Select(columns...)
+	}
+	selector.GroupBy(selector.Columns(*mpgb.flds...)...)
+	if err := selector.Err(); err != nil {
+		return err
+	}
+	rows := &sql.Rows{}
+	query, args := selector.Query()
+	if err := mpgb.build.driver.Query(ctx, query, args, rows); err != nil {
+		return err
+	}
+	defer rows.Close()
+	return sql.ScanSlice(rows, v)
+}
+
+// ModelProviderSelect is the builder for selecting fields of ModelProvider entities.
+type ModelProviderSelect struct {
+	*ModelProviderQuery
+	selector
+}
+
+// Aggregate adds the given aggregation functions to the selector query.
+func (mps *ModelProviderSelect) Aggregate(fns ...AggregateFunc) *ModelProviderSelect {
+	mps.fns = append(mps.fns, fns...)
+	return mps
+}
+
+// Scan applies the selector query and scans the result into the given value.
+func (mps *ModelProviderSelect) Scan(ctx context.Context, v any) error {
+	ctx = setContextOp(ctx, mps.ctx, ent.OpQuerySelect)
+	if err := mps.prepareQuery(ctx); err != nil {
+		return err
+	}
+	return scanWithInterceptors[*ModelProviderQuery, *ModelProviderSelect](ctx, mps.ModelProviderQuery, mps, mps.inters, v)
+}
+
+func (mps *ModelProviderSelect) sqlScan(ctx context.Context, root *ModelProviderQuery, v any) error {
+	selector := root.sqlQuery(ctx)
+	aggregation := make([]string, 0, len(mps.fns))
+	for _, fn := range mps.fns {
+		aggregation = append(aggregation, fn(selector))
+	}
+	switch n := len(*mps.selector.flds); {
+	case n == 0 && len(aggregation) > 0:
+		selector.Select(aggregation...)
+	case n != 0 && len(aggregation) > 0:
+		selector.AppendSelect(aggregation...)
+	}
+	rows := &sql.Rows{}
+	query, args := selector.Query()
+	if err := mps.driver.Query(ctx, query, args, rows); err != nil {
+		return err
+	}
+	defer rows.Close()
+	return sql.ScanSlice(rows, v)
+}
+
+// Modify adds a query modifier for attaching custom logic to queries.
+func (mps *ModelProviderSelect) Modify(modifiers ...func(s *sql.Selector)) *ModelProviderSelect {
+	mps.modifiers = append(mps.modifiers, modifiers...)
+	return mps
+}

backend/db/modelprovider_update.go

@@ -0,0 +1,584 @@
+// Code generated by ent, DO NOT EDIT.
+
+package db
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"time"
+
+	"entgo.io/ent/dialect/sql"
+	"entgo.io/ent/dialect/sql/sqlgraph"
+	"entgo.io/ent/schema/field"
+	"github.com/chaitin/MonkeyCode/backend/db/modelprovider"
+	"github.com/chaitin/MonkeyCode/backend/db/modelprovidermodel"
+	"github.com/chaitin/MonkeyCode/backend/db/predicate"
+	"github.com/google/uuid"
+)
+
+// ModelProviderUpdate is the builder for updating ModelProvider entities.
+type ModelProviderUpdate struct {
+	config
+	hooks     []Hook
+	mutation  *ModelProviderMutation
+	modifiers []func(*sql.UpdateBuilder)
+}
+
+// Where appends a list predicates to the ModelProviderUpdate builder.
+func (mpu *ModelProviderUpdate) Where(ps ...predicate.ModelProvider) *ModelProviderUpdate {
+	mpu.mutation.Where(ps...)
+	return mpu
+}
+
+// SetName sets the "name" field.
+func (mpu *ModelProviderUpdate) SetName(s string) *ModelProviderUpdate {
+	mpu.mutation.SetName(s)
+	return mpu
+}
+
+// SetNillableName sets the "name" field if the given value is not nil.
+func (mpu *ModelProviderUpdate) SetNillableName(s *string) *ModelProviderUpdate {
+	if s != nil {
+		mpu.SetName(*s)
+	}
+	return mpu
+}
+
+// SetAPIBase sets the "api_base" field.
+func (mpu *ModelProviderUpdate) SetAPIBase(s string) *ModelProviderUpdate {
+	mpu.mutation.SetAPIBase(s)
+	return mpu
+}
+
+// SetNillableAPIBase sets the "api_base" field if the given value is not nil.
+func (mpu *ModelProviderUpdate) SetNillableAPIBase(s *string) *ModelProviderUpdate {
+	if s != nil {
+		mpu.SetAPIBase(*s)
+	}
+	return mpu
+}
+
+// SetPriority sets the "priority" field.
+func (mpu *ModelProviderUpdate) SetPriority(i int) *ModelProviderUpdate {
+	mpu.mutation.ResetPriority()
+	mpu.mutation.SetPriority(i)
+	return mpu
+}
+
+// SetNillablePriority sets the "priority" field if the given value is not nil.
+func (mpu *ModelProviderUpdate) SetNillablePriority(i *int) *ModelProviderUpdate {
+	if i != nil {
+		mpu.SetPriority(*i)
+	}
+	return mpu
+}
+
+// AddPriority adds i to the "priority" field.
+func (mpu *ModelProviderUpdate) AddPriority(i int) *ModelProviderUpdate {
+	mpu.mutation.AddPriority(i)
+	return mpu
+}
+
+// SetCreatedAt sets the "created_at" field.
+func (mpu *ModelProviderUpdate) SetCreatedAt(t time.Time) *ModelProviderUpdate {
+	mpu.mutation.SetCreatedAt(t)
+	return mpu
+}
+
+// SetNillableCreatedAt sets the "created_at" field if the given value is not nil.
+func (mpu *ModelProviderUpdate) SetNillableCreatedAt(t *time.Time) *ModelProviderUpdate {
+	if t != nil {
+		mpu.SetCreatedAt(*t)
+	}
+	return mpu
+}
+
+// SetUpdatedAt sets the "updated_at" field.
+func (mpu *ModelProviderUpdate) SetUpdatedAt(t time.Time) *ModelProviderUpdate {
+	mpu.mutation.SetUpdatedAt(t)
+	return mpu
+}
+
+// AddModelIDs adds the "models" edge to the ModelProviderModel entity by IDs.
+func (mpu *ModelProviderUpdate) AddModelIDs(ids ...uuid.UUID) *ModelProviderUpdate {
+	mpu.mutation.AddModelIDs(ids...)
+	return mpu
+}
+
+// AddModels adds the "models" edges to the ModelProviderModel entity.
+func (mpu *ModelProviderUpdate) AddModels(m ...*ModelProviderModel) *ModelProviderUpdate {
+	ids := make([]uuid.UUID, len(m))
+	for i := range m {
+		ids[i] = m[i].ID
+	}
+	return mpu.AddModelIDs(ids...)
+}
+
+// Mutation returns the ModelProviderMutation object of the builder.
+func (mpu *ModelProviderUpdate) Mutation() *ModelProviderMutation {
+	return mpu.mutation
+}
+
+// ClearModels clears all "models" edges to the ModelProviderModel entity.
+func (mpu *ModelProviderUpdate) ClearModels() *ModelProviderUpdate {
+	mpu.mutation.ClearModels()
+	return mpu
+}
+
+// RemoveModelIDs removes the "models" edge to ModelProviderModel entities by IDs.
+func (mpu *ModelProviderUpdate) RemoveModelIDs(ids ...uuid.UUID) *ModelProviderUpdate {
+	mpu.mutation.RemoveModelIDs(ids...)
+	return mpu
+}
+
+// RemoveModels removes "models" edges to ModelProviderModel entities.
+func (mpu *ModelProviderUpdate) RemoveModels(m ...*ModelProviderModel) *ModelProviderUpdate {
+	ids := make([]uuid.UUID, len(m))
+	for i := range m {
+		ids[i] = m[i].ID
+	}
+	return mpu.RemoveModelIDs(ids...)
+}
+
+// Save executes the query and returns the number of nodes affected by the update operation.
+func (mpu *ModelProviderUpdate) Save(ctx context.Context) (int, error) {
+	mpu.defaults()
+	return withHooks(ctx, mpu.sqlSave, mpu.mutation, mpu.hooks)
+}
+
+// SaveX is like Save, but panics if an error occurs.
+func (mpu *ModelProviderUpdate) SaveX(ctx context.Context) int {
+	affected, err := mpu.Save(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return affected
+}
+
+// Exec executes the query.
+func (mpu *ModelProviderUpdate) Exec(ctx context.Context) error {
+	_, err := mpu.Save(ctx)
+	return err
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (mpu *ModelProviderUpdate) ExecX(ctx context.Context) {
+	if err := mpu.Exec(ctx); err != nil {
+		panic(err)
+	}
+}
+
+// defaults sets the default values of the builder before save.
+func (mpu *ModelProviderUpdate) defaults() {
+	if _, ok := mpu.mutation.UpdatedAt(); !ok {
+		v := modelprovider.UpdateDefaultUpdatedAt()
+		mpu.mutation.SetUpdatedAt(v)
+	}
+}
+
+// check runs all checks and user-defined validators on the builder.
+func (mpu *ModelProviderUpdate) check() error {
+	if v, ok := mpu.mutation.Name(); ok {
+		if err := modelprovider.NameValidator(v); err != nil {
+			return &ValidationError{Name: "name", err: fmt.Errorf(`db: validator failed for field "ModelProvider.name": %w`, err)}
+		}
+	}
+	if v, ok := mpu.mutation.APIBase(); ok {
+		if err := modelprovider.APIBaseValidator(v); err != nil {
+			return &ValidationError{Name: "api_base", err: fmt.Errorf(`db: validator failed for field "ModelProvider.api_base": %w`, err)}
+		}
+	}
+	return nil
+}
+
+// Modify adds a statement modifier for attaching custom logic to the UPDATE statement.
+func (mpu *ModelProviderUpdate) Modify(modifiers ...func(u *sql.UpdateBuilder)) *ModelProviderUpdate {
+	mpu.modifiers = append(mpu.modifiers, modifiers...)
+	return mpu
+}
+
+func (mpu *ModelProviderUpdate) sqlSave(ctx context.Context) (n int, err error) {
+	if err := mpu.check(); err != nil {
+		return n, err
+	}
+	_spec := sqlgraph.NewUpdateSpec(modelprovider.Table, modelprovider.Columns, sqlgraph.NewFieldSpec(modelprovider.FieldID, field.TypeString))
+	if ps := mpu.mutation.predicates; len(ps) > 0 {
+		_spec.Predicate = func(selector *sql.Selector) {
+			for i := range ps {
+				ps[i](selector)
+			}
+		}
+	}
+	if value, ok := mpu.mutation.Name(); ok {
+		_spec.SetField(modelprovider.FieldName, field.TypeString, value)
+	}
+	if value, ok := mpu.mutation.APIBase(); ok {
+		_spec.SetField(modelprovider.FieldAPIBase, field.TypeString, value)
+	}
+	if value, ok := mpu.mutation.Priority(); ok {
+		_spec.SetField(modelprovider.FieldPriority, field.TypeInt, value)
+	}
+	if value, ok := mpu.mutation.AddedPriority(); ok {
+		_spec.AddField(modelprovider.FieldPriority, field.TypeInt, value)
+	}
+	if value, ok := mpu.mutation.CreatedAt(); ok {
+		_spec.SetField(modelprovider.FieldCreatedAt, field.TypeTime, value)
+	}
+	if value, ok := mpu.mutation.UpdatedAt(); ok {
+		_spec.SetField(modelprovider.FieldUpdatedAt, field.TypeTime, value)
+	}
+	if mpu.mutation.ModelsCleared() {
+		edge := &sqlgraph.EdgeSpec{
+			Rel:     sqlgraph.O2M,
+			Inverse: false,
+			Table:   modelprovider.ModelsTable,
+			Columns: []string{modelprovider.ModelsColumn},
+			Bidi:    false,
+			Target: &sqlgraph.EdgeTarget{
+				IDSpec: sqlgraph.NewFieldSpec(modelprovidermodel.FieldID, field.TypeUUID),
+			},
+		}
+		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
+	}
+	if nodes := mpu.mutation.RemovedModelsIDs(); len(nodes) > 0 && !mpu.mutation.ModelsCleared() {
+		edge := &sqlgraph.EdgeSpec{
+			Rel:     sqlgraph.O2M,
+			Inverse: false,
+			Table:   modelprovider.ModelsTable,
+			Columns: []string{modelprovider.ModelsColumn},
+			Bidi:    false,
+			Target: &sqlgraph.EdgeTarget{
+				IDSpec: sqlgraph.NewFieldSpec(modelprovidermodel.FieldID, field.TypeUUID),
+			},
+		}
+		for _, k := range nodes {
+			edge.Target.Nodes = append(edge.Target.Nodes, k)
+		}
+		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
+	}
+	if nodes := mpu.mutation.ModelsIDs(); len(nodes) > 0 {
+		edge := &sqlgraph.EdgeSpec{
+			Rel:     sqlgraph.O2M,
+			Inverse: false,
+			Table:   modelprovider.ModelsTable,
+			Columns: []string{modelprovider.ModelsColumn},
+			Bidi:    false,
+			Target: &sqlgraph.EdgeTarget{
+				IDSpec: sqlgraph.NewFieldSpec(modelprovidermodel.FieldID, field.TypeUUID),
+			},
+		}
+		for _, k := range nodes {
+			edge.Target.Nodes = append(edge.Target.Nodes, k)
+		}
+		_spec.Edges.Add = append(_spec.Edges.Add, edge)
+	}
+	_spec.AddModifiers(mpu.modifiers...)
+	if n, err = sqlgraph.UpdateNodes(ctx, mpu.driver, _spec); err != nil {
+		if _, ok := err.(*sqlgraph.NotFoundError); ok {
+			err = &NotFoundError{modelprovider.Label}
+		} else if sqlgraph.IsConstraintError(err) {
+			err = &ConstraintError{msg: err.Error(), wrap: err}
+		}
+		return 0, err
+	}
+	mpu.mutation.done = true
+	return n, nil
+}
+
+// ModelProviderUpdateOne is the builder for updating a single ModelProvider entity.
+type ModelProviderUpdateOne struct {
+	config
+	fields    []string
+	hooks     []Hook
+	mutation  *ModelProviderMutation
+	modifiers []func(*sql.UpdateBuilder)
+}
+
+// SetName sets the "name" field.
+func (mpuo *ModelProviderUpdateOne) SetName(s string) *ModelProviderUpdateOne {
+	mpuo.mutation.SetName(s)
+	return mpuo
+}
+
+// SetNillableName sets the "name" field if the given value is not nil.
+func (mpuo *ModelProviderUpdateOne) SetNillableName(s *string) *ModelProviderUpdateOne {
+	if s != nil {
+		mpuo.SetName(*s)
+	}
+	return mpuo
+}
+
+// SetAPIBase sets the "api_base" field.
+func (mpuo *ModelProviderUpdateOne) SetAPIBase(s string) *ModelProviderUpdateOne {
+	mpuo.mutation.SetAPIBase(s)
+	return mpuo
+}
+
+// SetNillableAPIBase sets the "api_base" field if the given value is not nil.
+func (mpuo *ModelProviderUpdateOne) SetNillableAPIBase(s *string) *ModelProviderUpdateOne {
+	if s != nil {
+		mpuo.SetAPIBase(*s)
+	}
+	return mpuo
+}
+
+// SetPriority sets the "priority" field.
+func (mpuo *ModelProviderUpdateOne) SetPriority(i int) *ModelProviderUpdateOne {
+	mpuo.mutation.ResetPriority()
+	mpuo.mutation.SetPriority(i)
+	return mpuo
+}
+
+// SetNillablePriority sets the "priority" field if the given value is not nil.
+func (mpuo *ModelProviderUpdateOne) SetNillablePriority(i *int) *ModelProviderUpdateOne {
+	if i != nil {
+		mpuo.SetPriority(*i)
+	}
+	return mpuo
+}
+
+// AddPriority adds i to the "priority" field.
+func (mpuo *ModelProviderUpdateOne) AddPriority(i int) *ModelProviderUpdateOne {
+	mpuo.mutation.AddPriority(i)
+	return mpuo
+}
+
+// SetCreatedAt sets the "created_at" field.
+func (mpuo *ModelProviderUpdateOne) SetCreatedAt(t time.Time) *ModelProviderUpdateOne {
+	mpuo.mutation.SetCreatedAt(t)
+	return mpuo
+}
+
+// SetNillableCreatedAt sets the "created_at" field if the given value is not nil.
+func (mpuo *ModelProviderUpdateOne) SetNillableCreatedAt(t *time.Time) *ModelProviderUpdateOne {
+	if t != nil {
+		mpuo.SetCreatedAt(*t)
+	}
+	return mpuo
+}
+
+// SetUpdatedAt sets the "updated_at" field.
+func (mpuo *ModelProviderUpdateOne) SetUpdatedAt(t time.Time) *ModelProviderUpdateOne {
+	mpuo.mutation.SetUpdatedAt(t)
+	return mpuo
+}
+
+// AddModelIDs adds the "models" edge to the ModelProviderModel entity by IDs.
+func (mpuo *ModelProviderUpdateOne) AddModelIDs(ids ...uuid.UUID) *ModelProviderUpdateOne {
+	mpuo.mutation.AddModelIDs(ids...)
+	return mpuo
+}
+
+// AddModels adds the "models" edges to the ModelProviderModel entity.
+func (mpuo *ModelProviderUpdateOne) AddModels(m ...*ModelProviderModel) *ModelProviderUpdateOne {
+	ids := make([]uuid.UUID, len(m))
+	for i := range m {
+		ids[i] = m[i].ID
+	}
+	return mpuo.AddModelIDs(ids...)
+}
+
+// Mutation returns the ModelProviderMutation object of the builder.
+func (mpuo *ModelProviderUpdateOne) Mutation() *ModelProviderMutation {
+	return mpuo.mutation
+}
+
+// ClearModels clears all "models" edges to the ModelProviderModel entity.
+func (mpuo *ModelProviderUpdateOne) ClearModels() *ModelProviderUpdateOne {
+	mpuo.mutation.ClearModels()
+	return mpuo
+}
+
+// RemoveModelIDs removes the "models" edge to ModelProviderModel entities by IDs.
+func (mpuo *ModelProviderUpdateOne) RemoveModelIDs(ids ...uuid.UUID) *ModelProviderUpdateOne {
+	mpuo.mutation.RemoveModelIDs(ids...)
+	return mpuo
+}
+
+// RemoveModels removes "models" edges to ModelProviderModel entities.
+func (mpuo *ModelProviderUpdateOne) RemoveModels(m ...*ModelProviderModel) *ModelProviderUpdateOne {
+	ids := make([]uuid.UUID, len(m))
+	for i := range m {
+		ids[i] = m[i].ID
+	}
+	return mpuo.RemoveModelIDs(ids...)
+}
+
+// Where appends a list predicates to the ModelProviderUpdate builder.
+func (mpuo *ModelProviderUpdateOne) Where(ps ...predicate.ModelProvider) *ModelProviderUpdateOne {
+	mpuo.mutation.Where(ps...)
+	return mpuo
+}
+
+// Select allows selecting one or more fields (columns) of the returned entity.
+// The default is selecting all fields defined in the entity schema.
+func (mpuo *ModelProviderUpdateOne) Select(field string, fields ...string) *ModelProviderUpdateOne {
+	mpuo.fields = append([]string{field}, fields...)
+	return mpuo
+}
+
+// Save executes the query and returns the updated ModelProvider entity.
+func (mpuo *ModelProviderUpdateOne) Save(ctx context.Context) (*ModelProvider, error) {
+	mpuo.defaults()
+	return withHooks(ctx, mpuo.sqlSave, mpuo.mutation, mpuo.hooks)
+}
+
+// SaveX is like Save, but panics if an error occurs.
+func (mpuo *ModelProviderUpdateOne) SaveX(ctx context.Context) *ModelProvider {
+	node, err := mpuo.Save(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return node
+}
+
+// Exec executes the query on the entity.
+func (mpuo *ModelProviderUpdateOne) Exec(ctx context.Context) error {
+	_, err := mpuo.Save(ctx)
+	return err
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (mpuo *ModelProviderUpdateOne) ExecX(ctx context.Context) {
+	if err := mpuo.Exec(ctx); err != nil {
+		panic(err)
+	}
+}
+
+// defaults sets the default values of the builder before save.
+func (mpuo *ModelProviderUpdateOne) defaults() {
+	if _, ok := mpuo.mutation.UpdatedAt(); !ok {
+		v := modelprovider.UpdateDefaultUpdatedAt()
+		mpuo.mutation.SetUpdatedAt(v)
+	}
+}
+
+// check runs all checks and user-defined validators on the builder.
+func (mpuo *ModelProviderUpdateOne) check() error {
+	if v, ok := mpuo.mutation.Name(); ok {
+		if err := modelprovider.NameValidator(v); err != nil {
+			return &ValidationError{Name: "name", err: fmt.Errorf(`db: validator failed for field "ModelProvider.name": %w`, err)}
+		}
+	}
+	if v, ok := mpuo.mutation.APIBase(); ok {
+		if err := modelprovider.APIBaseValidator(v); err != nil {
+			return &ValidationError{Name: "api_base", err: fmt.Errorf(`db: validator failed for field "ModelProvider.api_base": %w`, err)}
+		}
+	}
+	return nil
+}
+
+// Modify adds a statement modifier for attaching custom logic to the UPDATE statement.
+func (mpuo *ModelProviderUpdateOne) Modify(modifiers ...func(u *sql.UpdateBuilder)) *ModelProviderUpdateOne {
+	mpuo.modifiers = append(mpuo.modifiers, modifiers...)
+	return mpuo
+}
+
+func (mpuo *ModelProviderUpdateOne) sqlSave(ctx context.Context) (_node *ModelProvider, err error) {
+	if err := mpuo.check(); err != nil {
+		return _node, err
+	}
+	_spec := sqlgraph.NewUpdateSpec(modelprovider.Table, modelprovider.Columns, sqlgraph.NewFieldSpec(modelprovider.FieldID, field.TypeString))
+	id, ok := mpuo.mutation.ID()
+	if !ok {
+		return nil, &ValidationError{Name: "id", err: errors.New(`db: missing "ModelProvider.id" for update`)}
+	}
+	_spec.Node.ID.Value = id
+	if fields := mpuo.fields; len(fields) > 0 {
+		_spec.Node.Columns = make([]string, 0, len(fields))
+		_spec.Node.Columns = append(_spec.Node.Columns, modelprovider.FieldID)
+		for _, f := range fields {
+			if !modelprovider.ValidColumn(f) {
+				return nil, &ValidationError{Name: f, err: fmt.Errorf("db: invalid field %q for query", f)}
+			}
+			if f != modelprovider.FieldID {
+				_spec.Node.Columns = append(_spec.Node.Columns, f)
+			}
+		}
+	}
+	if ps := mpuo.mutation.predicates; len(ps) > 0 {
+		_spec.Predicate = func(selector *sql.Selector) {
+			for i := range ps {
+				ps[i](selector)
+			}
+		}
+	}
+	if value, ok := mpuo.mutation.Name(); ok {
+		_spec.SetField(modelprovider.FieldName, field.TypeString, value)
+	}
+	if value, ok := mpuo.mutation.APIBase(); ok {
+		_spec.SetField(modelprovider.FieldAPIBase, field.TypeString, value)
+	}
+	if value, ok := mpuo.mutation.Priority(); ok {
+		_spec.SetField(modelprovider.FieldPriority, field.TypeInt, value)
+	}
+	if value, ok := mpuo.mutation.AddedPriority(); ok {
+		_spec.AddField(modelprovider.FieldPriority, field.TypeInt, value)
+	}
+	if value, ok := mpuo.mutation.CreatedAt(); ok {
+		_spec.SetField(modelprovider.FieldCreatedAt, field.TypeTime, value)
+	}
+	if value, ok := mpuo.mutation.UpdatedAt(); ok {
+		_spec.SetField(modelprovider.FieldUpdatedAt, field.TypeTime, value)
+	}
+	if mpuo.mutation.ModelsCleared() {
+		edge := &sqlgraph.EdgeSpec{
+			Rel:     sqlgraph.O2M,
+			Inverse: false,
+			Table:   modelprovider.ModelsTable,
+			Columns: []string{modelprovider.ModelsColumn},
+			Bidi:    false,
+			Target: &sqlgraph.EdgeTarget{
+				IDSpec: sqlgraph.NewFieldSpec(modelprovidermodel.FieldID, field.TypeUUID),
+			},
+		}
+		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
+	}
+	if nodes := mpuo.mutation.RemovedModelsIDs(); len(nodes) > 0 && !mpuo.mutation.ModelsCleared() {
+		edge := &sqlgraph.EdgeSpec{
+			Rel:     sqlgraph.O2M,
+			Inverse: false,
+			Table:   modelprovider.ModelsTable,
+			Columns: []string{modelprovider.ModelsColumn},
+			Bidi:    false,
+			Target: &sqlgraph.EdgeTarget{
+				IDSpec: sqlgraph.NewFieldSpec(modelprovidermodel.FieldID, field.TypeUUID),
+			},
+		}
+		for _, k := range nodes {
+			edge.Target.Nodes = append(edge.Target.Nodes, k)
+		}
+		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
+	}
+	if nodes := mpuo.mutation.ModelsIDs(); len(nodes) > 0 {
+		edge := &sqlgraph.EdgeSpec{
+			Rel:     sqlgraph.O2M,
+			Inverse: false,
+			Table:   modelprovider.ModelsTable,
+			Columns: []string{modelprovider.ModelsColumn},
+			Bidi:    false,
+			Target: &sqlgraph.EdgeTarget{
+				IDSpec: sqlgraph.NewFieldSpec(modelprovidermodel.FieldID, field.TypeUUID),
+			},
+		}
+		for _, k := range nodes {
+			edge.Target.Nodes = append(edge.Target.Nodes, k)
+		}
+		_spec.Edges.Add = append(_spec.Edges.Add, edge)
+	}
+	_spec.AddModifiers(mpuo.modifiers...)
+	_node = &ModelProvider{config: mpuo.config}
+	_spec.Assign = _node.assignValues
+	_spec.ScanValues = _node.scanValues
+	if err = sqlgraph.UpdateNode(ctx, mpuo.driver, _spec); err != nil {
+		if _, ok := err.(*sqlgraph.NotFoundError); ok {
+			err = &NotFoundError{modelprovider.Label}
+		} else if sqlgraph.IsConstraintError(err) {
+			err = &ConstraintError{msg: err.Error(), wrap: err}
+		}
+		return nil, err
+	}
+	mpuo.mutation.done = true
+	return _node, nil
+}

backend/db/modelprovidermodel.go

@@ -0,0 +1,169 @@
+// Code generated by ent, DO NOT EDIT.
+
+package db
+
+import (
+	"fmt"
+	"strings"
+	"time"
+
+	"entgo.io/ent"
+	"entgo.io/ent/dialect/sql"
+	"github.com/chaitin/MonkeyCode/backend/db/modelprovider"
+	"github.com/chaitin/MonkeyCode/backend/db/modelprovidermodel"
+	"github.com/google/uuid"
+)
+
+// ModelProviderModel is the model entity for the ModelProviderModel schema.
+type ModelProviderModel struct {
+	config `json:"-"`
+	// ID of the ent.
+	ID uuid.UUID `json:"id,omitempty"`
+	// Name holds the value of the "name" field.
+	Name string `json:"name,omitempty"`
+	// ProviderID holds the value of the "provider_id" field.
+	ProviderID string `json:"provider_id,omitempty"`
+	// CreatedAt holds the value of the "created_at" field.
+	CreatedAt time.Time `json:"created_at,omitempty"`
+	// UpdatedAt holds the value of the "updated_at" field.
+	UpdatedAt time.Time `json:"updated_at,omitempty"`
+	// Edges holds the relations/edges for other nodes in the graph.
+	// The values are being populated by the ModelProviderModelQuery when eager-loading is set.
+	Edges        ModelProviderModelEdges `json:"edges"`
+	selectValues sql.SelectValues
+}
+
+// ModelProviderModelEdges holds the relations/edges for other nodes in the graph.
+type ModelProviderModelEdges struct {
+	// Provider holds the value of the provider edge.
+	Provider *ModelProvider `json:"provider,omitempty"`
+	// loadedTypes holds the information for reporting if a
+	// type was loaded (or requested) in eager-loading or not.
+	loadedTypes [1]bool
+}
+
+// ProviderOrErr returns the Provider value or an error if the edge
+// was not loaded in eager-loading, or loaded but was not found.
+func (e ModelProviderModelEdges) ProviderOrErr() (*ModelProvider, error) {
+	if e.Provider != nil {
+		return e.Provider, nil
+	} else if e.loadedTypes[0] {
+		return nil, &NotFoundError{label: modelprovider.Label}
+	}
+	return nil, &NotLoadedError{edge: "provider"}
+}
+
+// scanValues returns the types for scanning values from sql.Rows.
+func (*ModelProviderModel) scanValues(columns []string) ([]any, error) {
+	values := make([]any, len(columns))
+	for i := range columns {
+		switch columns[i] {
+		case modelprovidermodel.FieldName, modelprovidermodel.FieldProviderID:
+			values[i] = new(sql.NullString)
+		case modelprovidermodel.FieldCreatedAt, modelprovidermodel.FieldUpdatedAt:
+			values[i] = new(sql.NullTime)
+		case modelprovidermodel.FieldID:
+			values[i] = new(uuid.UUID)
+		default:
+			values[i] = new(sql.UnknownType)
+		}
+	}
+	return values, nil
+}
+
+// assignValues assigns the values that were returned from sql.Rows (after scanning)
+// to the ModelProviderModel fields.
+func (mpm *ModelProviderModel) assignValues(columns []string, values []any) error {
+	if m, n := len(values), len(columns); m < n {
+		return fmt.Errorf("mismatch number of scan values: %d != %d", m, n)
+	}
+	for i := range columns {
+		switch columns[i] {
+		case modelprovidermodel.FieldID:
+			if value, ok := values[i].(*uuid.UUID); !ok {
+				return fmt.Errorf("unexpected type %T for field id", values[i])
+			} else if value != nil {
+				mpm.ID = *value
+			}
+		case modelprovidermodel.FieldName:
+			if value, ok := values[i].(*sql.NullString); !ok {
+				return fmt.Errorf("unexpected type %T for field name", values[i])
+			} else if value.Valid {
+				mpm.Name = value.String
+			}
+		case modelprovidermodel.FieldProviderID:
+			if value, ok := values[i].(*sql.NullString); !ok {
+				return fmt.Errorf("unexpected type %T for field provider_id", values[i])
+			} else if value.Valid {
+				mpm.ProviderID = value.String
+			}
+		case modelprovidermodel.FieldCreatedAt:
+			if value, ok := values[i].(*sql.NullTime); !ok {
+				return fmt.Errorf("unexpected type %T for field created_at", values[i])
+			} else if value.Valid {
+				mpm.CreatedAt = value.Time
+			}
+		case modelprovidermodel.FieldUpdatedAt:
+			if value, ok := values[i].(*sql.NullTime); !ok {
+				return fmt.Errorf("unexpected type %T for field updated_at", values[i])
+			} else if value.Valid {
+				mpm.UpdatedAt = value.Time
+			}
+		default:
+			mpm.selectValues.Set(columns[i], values[i])
+		}
+	}
+	return nil
+}
+
+// Value returns the ent.Value that was dynamically selected and assigned to the ModelProviderModel.
+// This includes values selected through modifiers, order, etc.
+func (mpm *ModelProviderModel) Value(name string) (ent.Value, error) {
+	return mpm.selectValues.Get(name)
+}
+
+// QueryProvider queries the "provider" edge of the ModelProviderModel entity.
+func (mpm *ModelProviderModel) QueryProvider() *ModelProviderQuery {
+	return NewModelProviderModelClient(mpm.config).QueryProvider(mpm)
+}
+
+// Update returns a builder for updating this ModelProviderModel.
+// Note that you need to call ModelProviderModel.Unwrap() before calling this method if this ModelProviderModel
+// was returned from a transaction, and the transaction was committed or rolled back.
+func (mpm *ModelProviderModel) Update() *ModelProviderModelUpdateOne {
+	return NewModelProviderModelClient(mpm.config).UpdateOne(mpm)
+}
+
+// Unwrap unwraps the ModelProviderModel entity that was returned from a transaction after it was closed,
+// so that all future queries will be executed through the driver which created the transaction.
+func (mpm *ModelProviderModel) Unwrap() *ModelProviderModel {
+	_tx, ok := mpm.config.driver.(*txDriver)
+	if !ok {
+		panic("db: ModelProviderModel is not a transactional entity")
+	}
+	mpm.config.driver = _tx.drv
+	return mpm
+}
+
+// String implements the fmt.Stringer.
+func (mpm *ModelProviderModel) String() string {
+	var builder strings.Builder
+	builder.WriteString("ModelProviderModel(")
+	builder.WriteString(fmt.Sprintf("id=%v, ", mpm.ID))
+	builder.WriteString("name=")
+	builder.WriteString(mpm.Name)
+	builder.WriteString(", ")
+	builder.WriteString("provider_id=")
+	builder.WriteString(mpm.ProviderID)
+	builder.WriteString(", ")
+	builder.WriteString("created_at=")
+	builder.WriteString(mpm.CreatedAt.Format(time.ANSIC))
+	builder.WriteString(", ")
+	builder.WriteString("updated_at=")
+	builder.WriteString(mpm.UpdatedAt.Format(time.ANSIC))
+	builder.WriteByte(')')
+	return builder.String()
+}
+
+// ModelProviderModels is a parsable slice of ModelProviderModel.
+type ModelProviderModels []*ModelProviderModel

backend/db/modelprovidermodel/modelprovidermodel.go

@@ -0,0 +1,111 @@
+// Code generated by ent, DO NOT EDIT.
+
+package modelprovidermodel
+
+import (
+	"time"
+
+	"entgo.io/ent/dialect/sql"
+	"entgo.io/ent/dialect/sql/sqlgraph"
+	"github.com/google/uuid"
+)
+
+const (
+	// Label holds the string label denoting the modelprovidermodel type in the database.
+	Label = "model_provider_model"
+	// FieldID holds the string denoting the id field in the database.
+	FieldID = "id"
+	// FieldName holds the string denoting the name field in the database.
+	FieldName = "name"
+	// FieldProviderID holds the string denoting the provider_id field in the database.
+	FieldProviderID = "provider_id"
+	// FieldCreatedAt holds the string denoting the created_at field in the database.
+	FieldCreatedAt = "created_at"
+	// FieldUpdatedAt holds the string denoting the updated_at field in the database.
+	FieldUpdatedAt = "updated_at"
+	// EdgeProvider holds the string denoting the provider edge name in mutations.
+	EdgeProvider = "provider"
+	// Table holds the table name of the modelprovidermodel in the database.
+	Table = "model_provider_models"
+	// ProviderTable is the table that holds the provider relation/edge.
+	ProviderTable = "model_provider_models"
+	// ProviderInverseTable is the table name for the ModelProvider entity.
+	// It exists in this package in order to avoid circular dependency with the "modelprovider" package.
+	ProviderInverseTable = "model_providers"
+	// ProviderColumn is the table column denoting the provider relation/edge.
+	ProviderColumn = "provider_id"
+)
+
+// Columns holds all SQL columns for modelprovidermodel fields.
+var Columns = []string{
+	FieldID,
+	FieldName,
+	FieldProviderID,
+	FieldCreatedAt,
+	FieldUpdatedAt,
+}
+
+// ValidColumn reports if the column name is valid (part of the table columns).
+func ValidColumn(column string) bool {
+	for i := range Columns {
+		if column == Columns[i] {
+			return true
+		}
+	}
+	return false
+}
+
+var (
+	// NameValidator is a validator for the "name" field. It is called by the builders before save.
+	NameValidator func(string) error
+	// DefaultCreatedAt holds the default value on creation for the "created_at" field.
+	DefaultCreatedAt func() time.Time
+	// DefaultUpdatedAt holds the default value on creation for the "updated_at" field.
+	DefaultUpdatedAt func() time.Time
+	// UpdateDefaultUpdatedAt holds the default value on update for the "updated_at" field.
+	UpdateDefaultUpdatedAt func() time.Time
+	// DefaultID holds the default value on creation for the "id" field.
+	DefaultID func() uuid.UUID
+)
+
+// OrderOption defines the ordering options for the ModelProviderModel queries.
+type OrderOption func(*sql.Selector)
+
+// ByID orders the results by the id field.
+func ByID(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldID, opts...).ToFunc()
+}
+
+// ByName orders the results by the name field.
+func ByName(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldName, opts...).ToFunc()
+}
+
+// ByProviderID orders the results by the provider_id field.
+func ByProviderID(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldProviderID, opts...).ToFunc()
+}
+
+// ByCreatedAt orders the results by the created_at field.
+func ByCreatedAt(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldCreatedAt, opts...).ToFunc()
+}
+
+// ByUpdatedAt orders the results by the updated_at field.
+func ByUpdatedAt(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldUpdatedAt, opts...).ToFunc()
+}
+
+// ByProviderField orders the results by provider field.
+func ByProviderField(field string, opts ...sql.OrderTermOption) OrderOption {
+	return func(s *sql.Selector) {
+		sqlgraph.OrderByNeighborTerms(s, newProviderStep(), sql.OrderByField(field, opts...))
+	}
+}
+func newProviderStep() *sqlgraph.Step {
+	return sqlgraph.NewStep(
+		sqlgraph.From(Table, FieldID),
+		sqlgraph.To(ProviderInverseTable, FieldID),
+		sqlgraph.Edge(sqlgraph.M2O, true, ProviderTable, ProviderColumn),
+	)
+}

backend/db/modelprovidermodel/where.go

@@ -0,0 +1,335 @@
+// Code generated by ent, DO NOT EDIT.
+
+package modelprovidermodel
+
+import (
+	"time"
+
+	"entgo.io/ent/dialect/sql"
+	"entgo.io/ent/dialect/sql/sqlgraph"
+	"github.com/chaitin/MonkeyCode/backend/db/predicate"
+	"github.com/google/uuid"
+)
+
+// ID filters vertices based on their ID field.
+func ID(id uuid.UUID) predicate.ModelProviderModel {
+	return predicate.ModelProviderModel(sql.FieldEQ(FieldID, id))
+}
+
+// IDEQ applies the EQ predicate on the ID field.
+func IDEQ(id uuid.UUID) predicate.ModelProviderModel {
+	return predicate.ModelProviderModel(sql.FieldEQ(FieldID, id))
+}
+
+// IDNEQ applies the NEQ predicate on the ID field.
+func IDNEQ(id uuid.UUID) predicate.ModelProviderModel {
+	return predicate.ModelProviderModel(sql.FieldNEQ(FieldID, id))
+}
+
+// IDIn applies the In predicate on the ID field.
+func IDIn(ids ...uuid.UUID) predicate.ModelProviderModel {
+	return predicate.ModelProviderModel(sql.FieldIn(FieldID, ids...))
+}
+
+// IDNotIn applies the NotIn predicate on the ID field.
+func IDNotIn(ids ...uuid.UUID) predicate.ModelProviderModel {
+	return predicate.ModelProviderModel(sql.FieldNotIn(FieldID, ids...))
+}
+
+// IDGT applies the GT predicate on the ID field.
+func IDGT(id uuid.UUID) predicate.ModelProviderModel {
+	return predicate.ModelProviderModel(sql.FieldGT(FieldID, id))
+}
+
+// IDGTE applies the GTE predicate on the ID field.
+func IDGTE(id uuid.UUID) predicate.ModelProviderModel {
+	return predicate.ModelProviderModel(sql.FieldGTE(FieldID, id))
+}
+
+// IDLT applies the LT predicate on the ID field.
+func IDLT(id uuid.UUID) predicate.ModelProviderModel {
+	return predicate.ModelProviderModel(sql.FieldLT(FieldID, id))
+}
+
+// IDLTE applies the LTE predicate on the ID field.
+func IDLTE(id uuid.UUID) predicate.ModelProviderModel {
+	return predicate.ModelProviderModel(sql.FieldLTE(FieldID, id))
+}
+
+// Name applies equality check predicate on the "name" field. It's identical to NameEQ.
+func Name(v string) predicate.ModelProviderModel {
+	return predicate.ModelProviderModel(sql.FieldEQ(FieldName, v))
+}
+
+// ProviderID applies equality check predicate on the "provider_id" field. It's identical to ProviderIDEQ.
+func ProviderID(v string) predicate.ModelProviderModel {
+	return predicate.ModelProviderModel(sql.FieldEQ(FieldProviderID, v))
+}
+
+// CreatedAt applies equality check predicate on the "created_at" field. It's identical to CreatedAtEQ.
+func CreatedAt(v time.Time) predicate.ModelProviderModel {
+	return predicate.ModelProviderModel(sql.FieldEQ(FieldCreatedAt, v))
+}
+
+// UpdatedAt applies equality check predicate on the "updated_at" field. It's identical to UpdatedAtEQ.
+func UpdatedAt(v time.Time) predicate.ModelProviderModel {
+	return predicate.ModelProviderModel(sql.FieldEQ(FieldUpdatedAt, v))
+}
+
+// NameEQ applies the EQ predicate on the "name" field.
+func NameEQ(v string) predicate.ModelProviderModel {
+	return predicate.ModelProviderModel(sql.FieldEQ(FieldName, v))
+}
+
+// NameNEQ applies the NEQ predicate on the "name" field.
+func NameNEQ(v string) predicate.ModelProviderModel {
+	return predicate.ModelProviderModel(sql.FieldNEQ(FieldName, v))
+}
+
+// NameIn applies the In predicate on the "name" field.
+func NameIn(vs ...string) predicate.ModelProviderModel {
+	return predicate.ModelProviderModel(sql.FieldIn(FieldName, vs...))
+}
+
+// NameNotIn applies the NotIn predicate on the "name" field.
+func NameNotIn(vs ...string) predicate.ModelProviderModel {
+	return predicate.ModelProviderModel(sql.FieldNotIn(FieldName, vs...))
+}
+
+// NameGT applies the GT predicate on the "name" field.
+func NameGT(v string) predicate.ModelProviderModel {
+	return predicate.ModelProviderModel(sql.FieldGT(FieldName, v))
+}
+
+// NameGTE applies the GTE predicate on the "name" field.
+func NameGTE(v string) predicate.ModelProviderModel {
+	return predicate.ModelProviderModel(sql.FieldGTE(FieldName, v))
+}
+
+// NameLT applies the LT predicate on the "name" field.
+func NameLT(v string) predicate.ModelProviderModel {
+	return predicate.ModelProviderModel(sql.FieldLT(FieldName, v))
+}
+
+// NameLTE applies the LTE predicate on the "name" field.
+func NameLTE(v string) predicate.ModelProviderModel {
+	return predicate.ModelProviderModel(sql.FieldLTE(FieldName, v))
+}
+
+// NameContains applies the Contains predicate on the "name" field.
+func NameContains(v string) predicate.ModelProviderModel {
+	return predicate.ModelProviderModel(sql.FieldContains(FieldName, v))
+}
+
+// NameHasPrefix applies the HasPrefix predicate on the "name" field.
+func NameHasPrefix(v string) predicate.ModelProviderModel {
+	return predicate.ModelProviderModel(sql.FieldHasPrefix(FieldName, v))
+}
+
+// NameHasSuffix applies the HasSuffix predicate on the "name" field.
+func NameHasSuffix(v string) predicate.ModelProviderModel {
+	return predicate.ModelProviderModel(sql.FieldHasSuffix(FieldName, v))
+}
+
+// NameEqualFold applies the EqualFold predicate on the "name" field.
+func NameEqualFold(v string) predicate.ModelProviderModel {
+	return predicate.ModelProviderModel(sql.FieldEqualFold(FieldName, v))
+}
+
+// NameContainsFold applies the ContainsFold predicate on the "name" field.
+func NameContainsFold(v string) predicate.ModelProviderModel {
+	return predicate.ModelProviderModel(sql.FieldContainsFold(FieldName, v))
+}
+
+// ProviderIDEQ applies the EQ predicate on the "provider_id" field.
+func ProviderIDEQ(v string) predicate.ModelProviderModel {
+	return predicate.ModelProviderModel(sql.FieldEQ(FieldProviderID, v))
+}
+
+// ProviderIDNEQ applies the NEQ predicate on the "provider_id" field.
+func ProviderIDNEQ(v string) predicate.ModelProviderModel {
+	return predicate.ModelProviderModel(sql.FieldNEQ(FieldProviderID, v))
+}
+
+// ProviderIDIn applies the In predicate on the "provider_id" field.
+func ProviderIDIn(vs ...string) predicate.ModelProviderModel {
+	return predicate.ModelProviderModel(sql.FieldIn(FieldProviderID, vs...))
+}
+
+// ProviderIDNotIn applies the NotIn predicate on the "provider_id" field.
+func ProviderIDNotIn(vs ...string) predicate.ModelProviderModel {
+	return predicate.ModelProviderModel(sql.FieldNotIn(FieldProviderID, vs...))
+}
+
+// ProviderIDGT applies the GT predicate on the "provider_id" field.
+func ProviderIDGT(v string) predicate.ModelProviderModel {
+	return predicate.ModelProviderModel(sql.FieldGT(FieldProviderID, v))
+}
+
+// ProviderIDGTE applies the GTE predicate on the "provider_id" field.
+func ProviderIDGTE(v string) predicate.ModelProviderModel {
+	return predicate.ModelProviderModel(sql.FieldGTE(FieldProviderID, v))
+}
+
+// ProviderIDLT applies the LT predicate on the "provider_id" field.
+func ProviderIDLT(v string) predicate.ModelProviderModel {
+	return predicate.ModelProviderModel(sql.FieldLT(FieldProviderID, v))
+}
+
+// ProviderIDLTE applies the LTE predicate on the "provider_id" field.
+func ProviderIDLTE(v string) predicate.ModelProviderModel {
+	return predicate.ModelProviderModel(sql.FieldLTE(FieldProviderID, v))
+}
+
+// ProviderIDContains applies the Contains predicate on the "provider_id" field.
+func ProviderIDContains(v string) predicate.ModelProviderModel {
+	return predicate.ModelProviderModel(sql.FieldContains(FieldProviderID, v))
+}
+
+// ProviderIDHasPrefix applies the HasPrefix predicate on the "provider_id" field.
+func ProviderIDHasPrefix(v string) predicate.ModelProviderModel {
+	return predicate.ModelProviderModel(sql.FieldHasPrefix(FieldProviderID, v))
+}
+
+// ProviderIDHasSuffix applies the HasSuffix predicate on the "provider_id" field.
+func ProviderIDHasSuffix(v string) predicate.ModelProviderModel {
+	return predicate.ModelProviderModel(sql.FieldHasSuffix(FieldProviderID, v))
+}
+
+// ProviderIDIsNil applies the IsNil predicate on the "provider_id" field.
+func ProviderIDIsNil() predicate.ModelProviderModel {
+	return predicate.ModelProviderModel(sql.FieldIsNull(FieldProviderID))
+}
+
+// ProviderIDNotNil applies the NotNil predicate on the "provider_id" field.
+func ProviderIDNotNil() predicate.ModelProviderModel {
+	return predicate.ModelProviderModel(sql.FieldNotNull(FieldProviderID))
+}
+
+// ProviderIDEqualFold applies the EqualFold predicate on the "provider_id" field.
+func ProviderIDEqualFold(v string) predicate.ModelProviderModel {
+	return predicate.ModelProviderModel(sql.FieldEqualFold(FieldProviderID, v))
+}
+
+// ProviderIDContainsFold applies the ContainsFold predicate on the "provider_id" field.
+func ProviderIDContainsFold(v string) predicate.ModelProviderModel {
+	return predicate.ModelProviderModel(sql.FieldContainsFold(FieldProviderID, v))
+}
+
+// CreatedAtEQ applies the EQ predicate on the "created_at" field.
+func CreatedAtEQ(v time.Time) predicate.ModelProviderModel {
+	return predicate.ModelProviderModel(sql.FieldEQ(FieldCreatedAt, v))
+}
+
+// CreatedAtNEQ applies the NEQ predicate on the "created_at" field.
+func CreatedAtNEQ(v time.Time) predicate.ModelProviderModel {
+	return predicate.ModelProviderModel(sql.FieldNEQ(FieldCreatedAt, v))
+}
+
+// CreatedAtIn applies the In predicate on the "created_at" field.
+func CreatedAtIn(vs ...time.Time) predicate.ModelProviderModel {
+	return predicate.ModelProviderModel(sql.FieldIn(FieldCreatedAt, vs...))
+}
+
+// CreatedAtNotIn applies the NotIn predicate on the "created_at" field.
+func CreatedAtNotIn(vs ...time.Time) predicate.ModelProviderModel {
+	return predicate.ModelProviderModel(sql.FieldNotIn(FieldCreatedAt, vs...))
+}
+
+// CreatedAtGT applies the GT predicate on the "created_at" field.
+func CreatedAtGT(v time.Time) predicate.ModelProviderModel {
+	return predicate.ModelProviderModel(sql.FieldGT(FieldCreatedAt, v))
+}
+
+// CreatedAtGTE applies the GTE predicate on the "created_at" field.
+func CreatedAtGTE(v time.Time) predicate.ModelProviderModel {
+	return predicate.ModelProviderModel(sql.FieldGTE(FieldCreatedAt, v))
+}
+
+// CreatedAtLT applies the LT predicate on the "created_at" field.
+func CreatedAtLT(v time.Time) predicate.ModelProviderModel {
+	return predicate.ModelProviderModel(sql.FieldLT(FieldCreatedAt, v))
+}
+
+// CreatedAtLTE applies the LTE predicate on the "created_at" field.
+func CreatedAtLTE(v time.Time) predicate.ModelProviderModel {
+	return predicate.ModelProviderModel(sql.FieldLTE(FieldCreatedAt, v))
+}
+
+// UpdatedAtEQ applies the EQ predicate on the "updated_at" field.
+func UpdatedAtEQ(v time.Time) predicate.ModelProviderModel {
+	return predicate.ModelProviderModel(sql.FieldEQ(FieldUpdatedAt, v))
+}
+
+// UpdatedAtNEQ applies the NEQ predicate on the "updated_at" field.
+func UpdatedAtNEQ(v time.Time) predicate.ModelProviderModel {
+	return predicate.ModelProviderModel(sql.FieldNEQ(FieldUpdatedAt, v))
+}
+
+// UpdatedAtIn applies the In predicate on the "updated_at" field.
+func UpdatedAtIn(vs ...time.Time) predicate.ModelProviderModel {
+	return predicate.ModelProviderModel(sql.FieldIn(FieldUpdatedAt, vs...))
+}
+
+// UpdatedAtNotIn applies the NotIn predicate on the "updated_at" field.
+func UpdatedAtNotIn(vs ...time.Time) predicate.ModelProviderModel {
+	return predicate.ModelProviderModel(sql.FieldNotIn(FieldUpdatedAt, vs...))
+}
+
+// UpdatedAtGT applies the GT predicate on the "updated_at" field.
+func UpdatedAtGT(v time.Time) predicate.ModelProviderModel {
+	return predicate.ModelProviderModel(sql.FieldGT(FieldUpdatedAt, v))
+}
+
+// UpdatedAtGTE applies the GTE predicate on the "updated_at" field.
+func UpdatedAtGTE(v time.Time) predicate.ModelProviderModel {
+	return predicate.ModelProviderModel(sql.FieldGTE(FieldUpdatedAt, v))
+}
+
+// UpdatedAtLT applies the LT predicate on the "updated_at" field.
+func UpdatedAtLT(v time.Time) predicate.ModelProviderModel {
+	return predicate.ModelProviderModel(sql.FieldLT(FieldUpdatedAt, v))
+}
+
+// UpdatedAtLTE applies the LTE predicate on the "updated_at" field.
+func UpdatedAtLTE(v time.Time) predicate.ModelProviderModel {
+	return predicate.ModelProviderModel(sql.FieldLTE(FieldUpdatedAt, v))
+}
+
+// HasProvider applies the HasEdge predicate on the "provider" edge.
+func HasProvider() predicate.ModelProviderModel {
+	return predicate.ModelProviderModel(func(s *sql.Selector) {
+		step := sqlgraph.NewStep(
+			sqlgraph.From(Table, FieldID),
+			sqlgraph.Edge(sqlgraph.M2O, true, ProviderTable, ProviderColumn),
+		)
+		sqlgraph.HasNeighbors(s, step)
+	})
+}
+
+// HasProviderWith applies the HasEdge predicate on the "provider" edge with a given conditions (other predicates).
+func HasProviderWith(preds ...predicate.ModelProvider) predicate.ModelProviderModel {
+	return predicate.ModelProviderModel(func(s *sql.Selector) {
+		step := newProviderStep()
+		sqlgraph.HasNeighborsWith(s, step, func(s *sql.Selector) {
+			for _, p := range preds {
+				p(s)
+			}
+		})
+	})
+}
+
+// And groups predicates with the AND operator between them.
+func And(predicates ...predicate.ModelProviderModel) predicate.ModelProviderModel {
+	return predicate.ModelProviderModel(sql.AndPredicates(predicates...))
+}
+
+// Or groups predicates with the OR operator between them.
+func Or(predicates ...predicate.ModelProviderModel) predicate.ModelProviderModel {
+	return predicate.ModelProviderModel(sql.OrPredicates(predicates...))
+}
+
+// Not applies the not operator on the given predicate.
+func Not(p predicate.ModelProviderModel) predicate.ModelProviderModel {
+	return predicate.ModelProviderModel(sql.NotPredicates(p))
+}

backend/db/modelprovidermodel_create.go

@@ -0,0 +1,741 @@
+// Code generated by ent, DO NOT EDIT.
+
+package db
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"time"
+
+	"entgo.io/ent/dialect"
+	"entgo.io/ent/dialect/sql"
+	"entgo.io/ent/dialect/sql/sqlgraph"
+	"entgo.io/ent/schema/field"
+	"github.com/chaitin/MonkeyCode/backend/db/modelprovider"
+	"github.com/chaitin/MonkeyCode/backend/db/modelprovidermodel"
+	"github.com/google/uuid"
+)
+
+// ModelProviderModelCreate is the builder for creating a ModelProviderModel entity.
+type ModelProviderModelCreate struct {
+	config
+	mutation *ModelProviderModelMutation
+	hooks    []Hook
+	conflict []sql.ConflictOption
+}
+
+// SetName sets the "name" field.
+func (mpmc *ModelProviderModelCreate) SetName(s string) *ModelProviderModelCreate {
+	mpmc.mutation.SetName(s)
+	return mpmc
+}
+
+// SetProviderID sets the "provider_id" field.
+func (mpmc *ModelProviderModelCreate) SetProviderID(s string) *ModelProviderModelCreate {
+	mpmc.mutation.SetProviderID(s)
+	return mpmc
+}
+
+// SetNillableProviderID sets the "provider_id" field if the given value is not nil.
+func (mpmc *ModelProviderModelCreate) SetNillableProviderID(s *string) *ModelProviderModelCreate {
+	if s != nil {
+		mpmc.SetProviderID(*s)
+	}
+	return mpmc
+}
+
+// SetCreatedAt sets the "created_at" field.
+func (mpmc *ModelProviderModelCreate) SetCreatedAt(t time.Time) *ModelProviderModelCreate {
+	mpmc.mutation.SetCreatedAt(t)
+	return mpmc
+}
+
+// SetNillableCreatedAt sets the "created_at" field if the given value is not nil.
+func (mpmc *ModelProviderModelCreate) SetNillableCreatedAt(t *time.Time) *ModelProviderModelCreate {
+	if t != nil {
+		mpmc.SetCreatedAt(*t)
+	}
+	return mpmc
+}
+
+// SetUpdatedAt sets the "updated_at" field.
+func (mpmc *ModelProviderModelCreate) SetUpdatedAt(t time.Time) *ModelProviderModelCreate {
+	mpmc.mutation.SetUpdatedAt(t)
+	return mpmc
+}
+
+// SetNillableUpdatedAt sets the "updated_at" field if the given value is not nil.
+func (mpmc *ModelProviderModelCreate) SetNillableUpdatedAt(t *time.Time) *ModelProviderModelCreate {
+	if t != nil {
+		mpmc.SetUpdatedAt(*t)
+	}
+	return mpmc
+}
+
+// SetID sets the "id" field.
+func (mpmc *ModelProviderModelCreate) SetID(u uuid.UUID) *ModelProviderModelCreate {
+	mpmc.mutation.SetID(u)
+	return mpmc
+}
+
+// SetNillableID sets the "id" field if the given value is not nil.
+func (mpmc *ModelProviderModelCreate) SetNillableID(u *uuid.UUID) *ModelProviderModelCreate {
+	if u != nil {
+		mpmc.SetID(*u)
+	}
+	return mpmc
+}
+
+// SetProvider sets the "provider" edge to the ModelProvider entity.
+func (mpmc *ModelProviderModelCreate) SetProvider(m *ModelProvider) *ModelProviderModelCreate {
+	return mpmc.SetProviderID(m.ID)
+}
+
+// Mutation returns the ModelProviderModelMutation object of the builder.
+func (mpmc *ModelProviderModelCreate) Mutation() *ModelProviderModelMutation {
+	return mpmc.mutation
+}
+
+// Save creates the ModelProviderModel in the database.
+func (mpmc *ModelProviderModelCreate) Save(ctx context.Context) (*ModelProviderModel, error) {
+	mpmc.defaults()
+	return withHooks(ctx, mpmc.sqlSave, mpmc.mutation, mpmc.hooks)
+}
+
+// SaveX calls Save and panics if Save returns an error.
+func (mpmc *ModelProviderModelCreate) SaveX(ctx context.Context) *ModelProviderModel {
+	v, err := mpmc.Save(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return v
+}
+
+// Exec executes the query.
+func (mpmc *ModelProviderModelCreate) Exec(ctx context.Context) error {
+	_, err := mpmc.Save(ctx)
+	return err
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (mpmc *ModelProviderModelCreate) ExecX(ctx context.Context) {
+	if err := mpmc.Exec(ctx); err != nil {
+		panic(err)
+	}
+}
+
+// defaults sets the default values of the builder before save.
+func (mpmc *ModelProviderModelCreate) defaults() {
+	if _, ok := mpmc.mutation.CreatedAt(); !ok {
+		v := modelprovidermodel.DefaultCreatedAt()
+		mpmc.mutation.SetCreatedAt(v)
+	}
+	if _, ok := mpmc.mutation.UpdatedAt(); !ok {
+		v := modelprovidermodel.DefaultUpdatedAt()
+		mpmc.mutation.SetUpdatedAt(v)
+	}
+	if _, ok := mpmc.mutation.ID(); !ok {
+		v := modelprovidermodel.DefaultID()
+		mpmc.mutation.SetID(v)
+	}
+}
+
+// check runs all checks and user-defined validators on the builder.
+func (mpmc *ModelProviderModelCreate) check() error {
+	if _, ok := mpmc.mutation.Name(); !ok {
+		return &ValidationError{Name: "name", err: errors.New(`db: missing required field "ModelProviderModel.name"`)}
+	}
+	if v, ok := mpmc.mutation.Name(); ok {
+		if err := modelprovidermodel.NameValidator(v); err != nil {
+			return &ValidationError{Name: "name", err: fmt.Errorf(`db: validator failed for field "ModelProviderModel.name": %w`, err)}
+		}
+	}
+	if _, ok := mpmc.mutation.CreatedAt(); !ok {
+		return &ValidationError{Name: "created_at", err: errors.New(`db: missing required field "ModelProviderModel.created_at"`)}
+	}
+	if _, ok := mpmc.mutation.UpdatedAt(); !ok {
+		return &ValidationError{Name: "updated_at", err: errors.New(`db: missing required field "ModelProviderModel.updated_at"`)}
+	}
+	return nil
+}
+
+func (mpmc *ModelProviderModelCreate) sqlSave(ctx context.Context) (*ModelProviderModel, error) {
+	if err := mpmc.check(); err != nil {
+		return nil, err
+	}
+	_node, _spec := mpmc.createSpec()
+	if err := sqlgraph.CreateNode(ctx, mpmc.driver, _spec); err != nil {
+		if sqlgraph.IsConstraintError(err) {
+			err = &ConstraintError{msg: err.Error(), wrap: err}
+		}
+		return nil, err
+	}
+	if _spec.ID.Value != nil {
+		if id, ok := _spec.ID.Value.(*uuid.UUID); ok {
+			_node.ID = *id
+		} else if err := _node.ID.Scan(_spec.ID.Value); err != nil {
+			return nil, err
+		}
+	}
+	mpmc.mutation.id = &_node.ID
+	mpmc.mutation.done = true
+	return _node, nil
+}
+
+func (mpmc *ModelProviderModelCreate) createSpec() (*ModelProviderModel, *sqlgraph.CreateSpec) {
+	var (
+		_node = &ModelProviderModel{config: mpmc.config}
+		_spec = sqlgraph.NewCreateSpec(modelprovidermodel.Table, sqlgraph.NewFieldSpec(modelprovidermodel.FieldID, field.TypeUUID))
+	)
+	_spec.OnConflict = mpmc.conflict
+	if id, ok := mpmc.mutation.ID(); ok {
+		_node.ID = id
+		_spec.ID.Value = &id
+	}
+	if value, ok := mpmc.mutation.Name(); ok {
+		_spec.SetField(modelprovidermodel.FieldName, field.TypeString, value)
+		_node.Name = value
+	}
+	if value, ok := mpmc.mutation.CreatedAt(); ok {
+		_spec.SetField(modelprovidermodel.FieldCreatedAt, field.TypeTime, value)
+		_node.CreatedAt = value
+	}
+	if value, ok := mpmc.mutation.UpdatedAt(); ok {
+		_spec.SetField(modelprovidermodel.FieldUpdatedAt, field.TypeTime, value)
+		_node.UpdatedAt = value
+	}
+	if nodes := mpmc.mutation.ProviderIDs(); len(nodes) > 0 {
+		edge := &sqlgraph.EdgeSpec{
+			Rel:     sqlgraph.M2O,
+			Inverse: true,
+			Table:   modelprovidermodel.ProviderTable,
+			Columns: []string{modelprovidermodel.ProviderColumn},
+			Bidi:    false,
+			Target: &sqlgraph.EdgeTarget{
+				IDSpec: sqlgraph.NewFieldSpec(modelprovider.FieldID, field.TypeString),
+			},
+		}
+		for _, k := range nodes {
+			edge.Target.Nodes = append(edge.Target.Nodes, k)
+		}
+		_node.ProviderID = nodes[0]
+		_spec.Edges = append(_spec.Edges, edge)
+	}
+	return _node, _spec
+}
+
+// OnConflict allows configuring the `ON CONFLICT` / `ON DUPLICATE KEY` clause
+// of the `INSERT` statement. For example:
+//
+//	client.ModelProviderModel.Create().
+//		SetName(v).
+//		OnConflict(
+//			// Update the row with the new values
+//			// the was proposed for insertion.
+//			sql.ResolveWithNewValues(),
+//		).
+//		// Override some of the fields with custom
+//		// update values.
+//		Update(func(u *ent.ModelProviderModelUpsert) {
+//			SetName(v+v).
+//		}).
+//		Exec(ctx)
+func (mpmc *ModelProviderModelCreate) OnConflict(opts ...sql.ConflictOption) *ModelProviderModelUpsertOne {
+	mpmc.conflict = opts
+	return &ModelProviderModelUpsertOne{
+		create: mpmc,
+	}
+}
+
+// OnConflictColumns calls `OnConflict` and configures the columns
+// as conflict target. Using this option is equivalent to using:
+//
+//	client.ModelProviderModel.Create().
+//		OnConflict(sql.ConflictColumns(columns...)).
+//		Exec(ctx)
+func (mpmc *ModelProviderModelCreate) OnConflictColumns(columns ...string) *ModelProviderModelUpsertOne {
+	mpmc.conflict = append(mpmc.conflict, sql.ConflictColumns(columns...))
+	return &ModelProviderModelUpsertOne{
+		create: mpmc,
+	}
+}
+
+type (
+	// ModelProviderModelUpsertOne is the builder for "upsert"-ing
+	//  one ModelProviderModel node.
+	ModelProviderModelUpsertOne struct {
+		create *ModelProviderModelCreate
+	}
+
+	// ModelProviderModelUpsert is the "OnConflict" setter.
+	ModelProviderModelUpsert struct {
+		*sql.UpdateSet
+	}
+)
+
+// SetName sets the "name" field.
+func (u *ModelProviderModelUpsert) SetName(v string) *ModelProviderModelUpsert {
+	u.Set(modelprovidermodel.FieldName, v)
+	return u
+}
+
+// UpdateName sets the "name" field to the value that was provided on create.
+func (u *ModelProviderModelUpsert) UpdateName() *ModelProviderModelUpsert {
+	u.SetExcluded(modelprovidermodel.FieldName)
+	return u
+}
+
+// SetProviderID sets the "provider_id" field.
+func (u *ModelProviderModelUpsert) SetProviderID(v string) *ModelProviderModelUpsert {
+	u.Set(modelprovidermodel.FieldProviderID, v)
+	return u
+}
+
+// UpdateProviderID sets the "provider_id" field to the value that was provided on create.
+func (u *ModelProviderModelUpsert) UpdateProviderID() *ModelProviderModelUpsert {
+	u.SetExcluded(modelprovidermodel.FieldProviderID)
+	return u
+}
+
+// ClearProviderID clears the value of the "provider_id" field.
+func (u *ModelProviderModelUpsert) ClearProviderID() *ModelProviderModelUpsert {
+	u.SetNull(modelprovidermodel.FieldProviderID)
+	return u
+}
+
+// SetCreatedAt sets the "created_at" field.
+func (u *ModelProviderModelUpsert) SetCreatedAt(v time.Time) *ModelProviderModelUpsert {
+	u.Set(modelprovidermodel.FieldCreatedAt, v)
+	return u
+}
+
+// UpdateCreatedAt sets the "created_at" field to the value that was provided on create.
+func (u *ModelProviderModelUpsert) UpdateCreatedAt() *ModelProviderModelUpsert {
+	u.SetExcluded(modelprovidermodel.FieldCreatedAt)
+	return u
+}
+
+// SetUpdatedAt sets the "updated_at" field.
+func (u *ModelProviderModelUpsert) SetUpdatedAt(v time.Time) *ModelProviderModelUpsert {
+	u.Set(modelprovidermodel.FieldUpdatedAt, v)
+	return u
+}
+
+// UpdateUpdatedAt sets the "updated_at" field to the value that was provided on create.
+func (u *ModelProviderModelUpsert) UpdateUpdatedAt() *ModelProviderModelUpsert {
+	u.SetExcluded(modelprovidermodel.FieldUpdatedAt)
+	return u
+}
+
+// UpdateNewValues updates the mutable fields using the new values that were set on create except the ID field.
+// Using this option is equivalent to using:
+//
+//	client.ModelProviderModel.Create().
+//		OnConflict(
+//			sql.ResolveWithNewValues(),
+//			sql.ResolveWith(func(u *sql.UpdateSet) {
+//				u.SetIgnore(modelprovidermodel.FieldID)
+//			}),
+//		).
+//		Exec(ctx)
+func (u *ModelProviderModelUpsertOne) UpdateNewValues() *ModelProviderModelUpsertOne {
+	u.create.conflict = append(u.create.conflict, sql.ResolveWithNewValues())
+	u.create.conflict = append(u.create.conflict, sql.ResolveWith(func(s *sql.UpdateSet) {
+		if _, exists := u.create.mutation.ID(); exists {
+			s.SetIgnore(modelprovidermodel.FieldID)
+		}
+	}))
+	return u
+}
+
+// Ignore sets each column to itself in case of conflict.
+// Using this option is equivalent to using:
+//
+//	client.ModelProviderModel.Create().
+//	    OnConflict(sql.ResolveWithIgnore()).
+//	    Exec(ctx)
+func (u *ModelProviderModelUpsertOne) Ignore() *ModelProviderModelUpsertOne {
+	u.create.conflict = append(u.create.conflict, sql.ResolveWithIgnore())
+	return u
+}
+
+// DoNothing configures the conflict_action to `DO NOTHING`.
+// Supported only by SQLite and PostgreSQL.
+func (u *ModelProviderModelUpsertOne) DoNothing() *ModelProviderModelUpsertOne {
+	u.create.conflict = append(u.create.conflict, sql.DoNothing())
+	return u
+}
+
+// Update allows overriding fields `UPDATE` values. See the ModelProviderModelCreate.OnConflict
+// documentation for more info.
+func (u *ModelProviderModelUpsertOne) Update(set func(*ModelProviderModelUpsert)) *ModelProviderModelUpsertOne {
+	u.create.conflict = append(u.create.conflict, sql.ResolveWith(func(update *sql.UpdateSet) {
+		set(&ModelProviderModelUpsert{UpdateSet: update})
+	}))
+	return u
+}
+
+// SetName sets the "name" field.
+func (u *ModelProviderModelUpsertOne) SetName(v string) *ModelProviderModelUpsertOne {
+	return u.Update(func(s *ModelProviderModelUpsert) {
+		s.SetName(v)
+	})
+}
+
+// UpdateName sets the "name" field to the value that was provided on create.
+func (u *ModelProviderModelUpsertOne) UpdateName() *ModelProviderModelUpsertOne {
+	return u.Update(func(s *ModelProviderModelUpsert) {
+		s.UpdateName()
+	})
+}
+
+// SetProviderID sets the "provider_id" field.
+func (u *ModelProviderModelUpsertOne) SetProviderID(v string) *ModelProviderModelUpsertOne {
+	return u.Update(func(s *ModelProviderModelUpsert) {
+		s.SetProviderID(v)
+	})
+}
+
+// UpdateProviderID sets the "provider_id" field to the value that was provided on create.
+func (u *ModelProviderModelUpsertOne) UpdateProviderID() *ModelProviderModelUpsertOne {
+	return u.Update(func(s *ModelProviderModelUpsert) {
+		s.UpdateProviderID()
+	})
+}
+
+// ClearProviderID clears the value of the "provider_id" field.
+func (u *ModelProviderModelUpsertOne) ClearProviderID() *ModelProviderModelUpsertOne {
+	return u.Update(func(s *ModelProviderModelUpsert) {
+		s.ClearProviderID()
+	})
+}
+
+// SetCreatedAt sets the "created_at" field.
+func (u *ModelProviderModelUpsertOne) SetCreatedAt(v time.Time) *ModelProviderModelUpsertOne {
+	return u.Update(func(s *ModelProviderModelUpsert) {
+		s.SetCreatedAt(v)
+	})
+}
+
+// UpdateCreatedAt sets the "created_at" field to the value that was provided on create.
+func (u *ModelProviderModelUpsertOne) UpdateCreatedAt() *ModelProviderModelUpsertOne {
+	return u.Update(func(s *ModelProviderModelUpsert) {
+		s.UpdateCreatedAt()
+	})
+}
+
+// SetUpdatedAt sets the "updated_at" field.
+func (u *ModelProviderModelUpsertOne) SetUpdatedAt(v time.Time) *ModelProviderModelUpsertOne {
+	return u.Update(func(s *ModelProviderModelUpsert) {
+		s.SetUpdatedAt(v)
+	})
+}
+
+// UpdateUpdatedAt sets the "updated_at" field to the value that was provided on create.
+func (u *ModelProviderModelUpsertOne) UpdateUpdatedAt() *ModelProviderModelUpsertOne {
+	return u.Update(func(s *ModelProviderModelUpsert) {
+		s.UpdateUpdatedAt()
+	})
+}
+
+// Exec executes the query.
+func (u *ModelProviderModelUpsertOne) Exec(ctx context.Context) error {
+	if len(u.create.conflict) == 0 {
+		return errors.New("db: missing options for ModelProviderModelCreate.OnConflict")
+	}
+	return u.create.Exec(ctx)
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (u *ModelProviderModelUpsertOne) ExecX(ctx context.Context) {
+	if err := u.create.Exec(ctx); err != nil {
+		panic(err)
+	}
+}
+
+// Exec executes the UPSERT query and returns the inserted/updated ID.
+func (u *ModelProviderModelUpsertOne) ID(ctx context.Context) (id uuid.UUID, err error) {
+	if u.create.driver.Dialect() == dialect.MySQL {
+		// In case of "ON CONFLICT", there is no way to get back non-numeric ID
+		// fields from the database since MySQL does not support the RETURNING clause.
+		return id, errors.New("db: ModelProviderModelUpsertOne.ID is not supported by MySQL driver. Use ModelProviderModelUpsertOne.Exec instead")
+	}
+	node, err := u.create.Save(ctx)
+	if err != nil {
+		return id, err
+	}
+	return node.ID, nil
+}
+
+// IDX is like ID, but panics if an error occurs.
+func (u *ModelProviderModelUpsertOne) IDX(ctx context.Context) uuid.UUID {
+	id, err := u.ID(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return id
+}
+
+// ModelProviderModelCreateBulk is the builder for creating many ModelProviderModel entities in bulk.
+type ModelProviderModelCreateBulk struct {
+	config
+	err      error
+	builders []*ModelProviderModelCreate
+	conflict []sql.ConflictOption
+}
+
+// Save creates the ModelProviderModel entities in the database.
+func (mpmcb *ModelProviderModelCreateBulk) Save(ctx context.Context) ([]*ModelProviderModel, error) {
+	if mpmcb.err != nil {
+		return nil, mpmcb.err
+	}
+	specs := make([]*sqlgraph.CreateSpec, len(mpmcb.builders))
+	nodes := make([]*ModelProviderModel, len(mpmcb.builders))
+	mutators := make([]Mutator, len(mpmcb.builders))
+	for i := range mpmcb.builders {
+		func(i int, root context.Context) {
+			builder := mpmcb.builders[i]
+			builder.defaults()
+			var mut Mutator = MutateFunc(func(ctx context.Context, m Mutation) (Value, error) {
+				mutation, ok := m.(*ModelProviderModelMutation)
+				if !ok {
+					return nil, fmt.Errorf("unexpected mutation type %T", m)
+				}
+				if err := builder.check(); err != nil {
+					return nil, err
+				}
+				builder.mutation = mutation
+				var err error
+				nodes[i], specs[i] = builder.createSpec()
+				if i < len(mutators)-1 {
+					_, err = mutators[i+1].Mutate(root, mpmcb.builders[i+1].mutation)
+				} else {
+					spec := &sqlgraph.BatchCreateSpec{Nodes: specs}
+					spec.OnConflict = mpmcb.conflict
+					// Invoke the actual operation on the latest mutation in the chain.
+					if err = sqlgraph.BatchCreate(ctx, mpmcb.driver, spec); err != nil {
+						if sqlgraph.IsConstraintError(err) {
+							err = &ConstraintError{msg: err.Error(), wrap: err}
+						}
+					}
+				}
+				if err != nil {
+					return nil, err
+				}
+				mutation.id = &nodes[i].ID
+				mutation.done = true
+				return nodes[i], nil
+			})
+			for i := len(builder.hooks) - 1; i >= 0; i-- {
+				mut = builder.hooks[i](mut)
+			}
+			mutators[i] = mut
+		}(i, ctx)
+	}
+	if len(mutators) > 0 {
+		if _, err := mutators[0].Mutate(ctx, mpmcb.builders[0].mutation); err != nil {
+			return nil, err
+		}
+	}
+	return nodes, nil
+}
+
+// SaveX is like Save, but panics if an error occurs.
+func (mpmcb *ModelProviderModelCreateBulk) SaveX(ctx context.Context) []*ModelProviderModel {
+	v, err := mpmcb.Save(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return v
+}
+
+// Exec executes the query.
+func (mpmcb *ModelProviderModelCreateBulk) Exec(ctx context.Context) error {
+	_, err := mpmcb.Save(ctx)
+	return err
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (mpmcb *ModelProviderModelCreateBulk) ExecX(ctx context.Context) {
+	if err := mpmcb.Exec(ctx); err != nil {
+		panic(err)
+	}
+}
+
+// OnConflict allows configuring the `ON CONFLICT` / `ON DUPLICATE KEY` clause
+// of the `INSERT` statement. For example:
+//
+//	client.ModelProviderModel.CreateBulk(builders...).
+//		OnConflict(
+//			// Update the row with the new values
+//			// the was proposed for insertion.
+//			sql.ResolveWithNewValues(),
+//		).
+//		// Override some of the fields with custom
+//		// update values.
+//		Update(func(u *ent.ModelProviderModelUpsert) {
+//			SetName(v+v).
+//		}).
+//		Exec(ctx)
+func (mpmcb *ModelProviderModelCreateBulk) OnConflict(opts ...sql.ConflictOption) *ModelProviderModelUpsertBulk {
+	mpmcb.conflict = opts
+	return &ModelProviderModelUpsertBulk{
+		create: mpmcb,
+	}
+}
+
+// OnConflictColumns calls `OnConflict` and configures the columns
+// as conflict target. Using this option is equivalent to using:
+//
+//	client.ModelProviderModel.Create().
+//		OnConflict(sql.ConflictColumns(columns...)).
+//		Exec(ctx)
+func (mpmcb *ModelProviderModelCreateBulk) OnConflictColumns(columns ...string) *ModelProviderModelUpsertBulk {
+	mpmcb.conflict = append(mpmcb.conflict, sql.ConflictColumns(columns...))
+	return &ModelProviderModelUpsertBulk{
+		create: mpmcb,
+	}
+}
+
+// ModelProviderModelUpsertBulk is the builder for "upsert"-ing
+// a bulk of ModelProviderModel nodes.
+type ModelProviderModelUpsertBulk struct {
+	create *ModelProviderModelCreateBulk
+}
+
+// UpdateNewValues updates the mutable fields using the new values that
+// were set on create. Using this option is equivalent to using:
+//
+//	client.ModelProviderModel.Create().
+//		OnConflict(
+//			sql.ResolveWithNewValues(),
+//			sql.ResolveWith(func(u *sql.UpdateSet) {
+//				u.SetIgnore(modelprovidermodel.FieldID)
+//			}),
+//		).
+//		Exec(ctx)
+func (u *ModelProviderModelUpsertBulk) UpdateNewValues() *ModelProviderModelUpsertBulk {
+	u.create.conflict = append(u.create.conflict, sql.ResolveWithNewValues())
+	u.create.conflict = append(u.create.conflict, sql.ResolveWith(func(s *sql.UpdateSet) {
+		for _, b := range u.create.builders {
+			if _, exists := b.mutation.ID(); exists {
+				s.SetIgnore(modelprovidermodel.FieldID)
+			}
+		}
+	}))
+	return u
+}
+
+// Ignore sets each column to itself in case of conflict.
+// Using this option is equivalent to using:
+//
+//	client.ModelProviderModel.Create().
+//		OnConflict(sql.ResolveWithIgnore()).
+//		Exec(ctx)
+func (u *ModelProviderModelUpsertBulk) Ignore() *ModelProviderModelUpsertBulk {
+	u.create.conflict = append(u.create.conflict, sql.ResolveWithIgnore())
+	return u
+}
+
+// DoNothing configures the conflict_action to `DO NOTHING`.
+// Supported only by SQLite and PostgreSQL.
+func (u *ModelProviderModelUpsertBulk) DoNothing() *ModelProviderModelUpsertBulk {
+	u.create.conflict = append(u.create.conflict, sql.DoNothing())
+	return u
+}
+
+// Update allows overriding fields `UPDATE` values. See the ModelProviderModelCreateBulk.OnConflict
+// documentation for more info.
+func (u *ModelProviderModelUpsertBulk) Update(set func(*ModelProviderModelUpsert)) *ModelProviderModelUpsertBulk {
+	u.create.conflict = append(u.create.conflict, sql.ResolveWith(func(update *sql.UpdateSet) {
+		set(&ModelProviderModelUpsert{UpdateSet: update})
+	}))
+	return u
+}
+
+// SetName sets the "name" field.
+func (u *ModelProviderModelUpsertBulk) SetName(v string) *ModelProviderModelUpsertBulk {
+	return u.Update(func(s *ModelProviderModelUpsert) {
+		s.SetName(v)
+	})
+}
+
+// UpdateName sets the "name" field to the value that was provided on create.
+func (u *ModelProviderModelUpsertBulk) UpdateName() *ModelProviderModelUpsertBulk {
+	return u.Update(func(s *ModelProviderModelUpsert) {
+		s.UpdateName()
+	})
+}
+
+// SetProviderID sets the "provider_id" field.
+func (u *ModelProviderModelUpsertBulk) SetProviderID(v string) *ModelProviderModelUpsertBulk {
+	return u.Update(func(s *ModelProviderModelUpsert) {
+		s.SetProviderID(v)
+	})
+}
+
+// UpdateProviderID sets the "provider_id" field to the value that was provided on create.
+func (u *ModelProviderModelUpsertBulk) UpdateProviderID() *ModelProviderModelUpsertBulk {
+	return u.Update(func(s *ModelProviderModelUpsert) {
+		s.UpdateProviderID()
+	})
+}
+
+// ClearProviderID clears the value of the "provider_id" field.
+func (u *ModelProviderModelUpsertBulk) ClearProviderID() *ModelProviderModelUpsertBulk {
+	return u.Update(func(s *ModelProviderModelUpsert) {
+		s.ClearProviderID()
+	})
+}
+
+// SetCreatedAt sets the "created_at" field.
+func (u *ModelProviderModelUpsertBulk) SetCreatedAt(v time.Time) *ModelProviderModelUpsertBulk {
+	return u.Update(func(s *ModelProviderModelUpsert) {
+		s.SetCreatedAt(v)
+	})
+}
+
+// UpdateCreatedAt sets the "created_at" field to the value that was provided on create.
+func (u *ModelProviderModelUpsertBulk) UpdateCreatedAt() *ModelProviderModelUpsertBulk {
+	return u.Update(func(s *ModelProviderModelUpsert) {
+		s.UpdateCreatedAt()
+	})
+}
+
+// SetUpdatedAt sets the "updated_at" field.
+func (u *ModelProviderModelUpsertBulk) SetUpdatedAt(v time.Time) *ModelProviderModelUpsertBulk {
+	return u.Update(func(s *ModelProviderModelUpsert) {
+		s.SetUpdatedAt(v)
+	})
+}
+
+// UpdateUpdatedAt sets the "updated_at" field to the value that was provided on create.
+func (u *ModelProviderModelUpsertBulk) UpdateUpdatedAt() *ModelProviderModelUpsertBulk {
+	return u.Update(func(s *ModelProviderModelUpsert) {
+		s.UpdateUpdatedAt()
+	})
+}
+
+// Exec executes the query.
+func (u *ModelProviderModelUpsertBulk) Exec(ctx context.Context) error {
+	if u.create.err != nil {
+		return u.create.err
+	}
+	for i, b := range u.create.builders {
+		if len(b.conflict) != 0 {
+			return fmt.Errorf("db: OnConflict was set for builder %d. Set it on the ModelProviderModelCreateBulk instead", i)
+		}
+	}
+	if len(u.create.conflict) == 0 {
+		return errors.New("db: missing options for ModelProviderModelCreateBulk.OnConflict")
+	}
+	return u.create.Exec(ctx)
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (u *ModelProviderModelUpsertBulk) ExecX(ctx context.Context) {
+	if err := u.create.Exec(ctx); err != nil {
+		panic(err)
+	}
+}

backend/db/modelprovidermodel_delete.go

@@ -0,0 +1,88 @@
+// Code generated by ent, DO NOT EDIT.
+
+package db
+
+import (
+	"context"
+
+	"entgo.io/ent/dialect/sql"
+	"entgo.io/ent/dialect/sql/sqlgraph"
+	"entgo.io/ent/schema/field"
+	"github.com/chaitin/MonkeyCode/backend/db/modelprovidermodel"
+	"github.com/chaitin/MonkeyCode/backend/db/predicate"
+)
+
+// ModelProviderModelDelete is the builder for deleting a ModelProviderModel entity.
+type ModelProviderModelDelete struct {
+	config
+	hooks    []Hook
+	mutation *ModelProviderModelMutation
+}
+
+// Where appends a list predicates to the ModelProviderModelDelete builder.
+func (mpmd *ModelProviderModelDelete) Where(ps ...predicate.ModelProviderModel) *ModelProviderModelDelete {
+	mpmd.mutation.Where(ps...)
+	return mpmd
+}
+
+// Exec executes the deletion query and returns how many vertices were deleted.
+func (mpmd *ModelProviderModelDelete) Exec(ctx context.Context) (int, error) {
+	return withHooks(ctx, mpmd.sqlExec, mpmd.mutation, mpmd.hooks)
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (mpmd *ModelProviderModelDelete) ExecX(ctx context.Context) int {
+	n, err := mpmd.Exec(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return n
+}
+
+func (mpmd *ModelProviderModelDelete) sqlExec(ctx context.Context) (int, error) {
+	_spec := sqlgraph.NewDeleteSpec(modelprovidermodel.Table, sqlgraph.NewFieldSpec(modelprovidermodel.FieldID, field.TypeUUID))
+	if ps := mpmd.mutation.predicates; len(ps) > 0 {
+		_spec.Predicate = func(selector *sql.Selector) {
+			for i := range ps {
+				ps[i](selector)
+			}
+		}
+	}
+	affected, err := sqlgraph.DeleteNodes(ctx, mpmd.driver, _spec)
+	if err != nil && sqlgraph.IsConstraintError(err) {
+		err = &ConstraintError{msg: err.Error(), wrap: err}
+	}
+	mpmd.mutation.done = true
+	return affected, err
+}
+
+// ModelProviderModelDeleteOne is the builder for deleting a single ModelProviderModel entity.
+type ModelProviderModelDeleteOne struct {
+	mpmd *ModelProviderModelDelete
+}
+
+// Where appends a list predicates to the ModelProviderModelDelete builder.
+func (mpmdo *ModelProviderModelDeleteOne) Where(ps ...predicate.ModelProviderModel) *ModelProviderModelDeleteOne {
+	mpmdo.mpmd.mutation.Where(ps...)
+	return mpmdo
+}
+
+// Exec executes the deletion query.
+func (mpmdo *ModelProviderModelDeleteOne) Exec(ctx context.Context) error {
+	n, err := mpmdo.mpmd.Exec(ctx)
+	switch {
+	case err != nil:
+		return err
+	case n == 0:
+		return &NotFoundError{modelprovidermodel.Label}
+	default:
+		return nil
+	}
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (mpmdo *ModelProviderModelDeleteOne) ExecX(ctx context.Context) {
+	if err := mpmdo.Exec(ctx); err != nil {
+		panic(err)
+	}
+}

backend/db/modelprovidermodel_query.go

@@ -0,0 +1,657 @@
+// Code generated by ent, DO NOT EDIT.
+
+package db
+
+import (
+	"context"
+	"fmt"
+	"math"
+
+	"entgo.io/ent"
+	"entgo.io/ent/dialect"
+	"entgo.io/ent/dialect/sql"
+	"entgo.io/ent/dialect/sql/sqlgraph"
+	"entgo.io/ent/schema/field"
+	"github.com/chaitin/MonkeyCode/backend/db/modelprovider"
+	"github.com/chaitin/MonkeyCode/backend/db/modelprovidermodel"
+	"github.com/chaitin/MonkeyCode/backend/db/predicate"
+	"github.com/google/uuid"
+)
+
+// ModelProviderModelQuery is the builder for querying ModelProviderModel entities.
+type ModelProviderModelQuery struct {
+	config
+	ctx          *QueryContext
+	order        []modelprovidermodel.OrderOption
+	inters       []Interceptor
+	predicates   []predicate.ModelProviderModel
+	withProvider *ModelProviderQuery
+	modifiers    []func(*sql.Selector)
+	// intermediate query (i.e. traversal path).
+	sql  *sql.Selector
+	path func(context.Context) (*sql.Selector, error)
+}
+
+// Where adds a new predicate for the ModelProviderModelQuery builder.
+func (mpmq *ModelProviderModelQuery) Where(ps ...predicate.ModelProviderModel) *ModelProviderModelQuery {
+	mpmq.predicates = append(mpmq.predicates, ps...)
+	return mpmq
+}
+
+// Limit the number of records to be returned by this query.
+func (mpmq *ModelProviderModelQuery) Limit(limit int) *ModelProviderModelQuery {
+	mpmq.ctx.Limit = &limit
+	return mpmq
+}
+
+// Offset to start from.
+func (mpmq *ModelProviderModelQuery) Offset(offset int) *ModelProviderModelQuery {
+	mpmq.ctx.Offset = &offset
+	return mpmq
+}
+
+// Unique configures the query builder to filter duplicate records on query.
+// By default, unique is set to true, and can be disabled using this method.
+func (mpmq *ModelProviderModelQuery) Unique(unique bool) *ModelProviderModelQuery {
+	mpmq.ctx.Unique = &unique
+	return mpmq
+}
+
+// Order specifies how the records should be ordered.
+func (mpmq *ModelProviderModelQuery) Order(o ...modelprovidermodel.OrderOption) *ModelProviderModelQuery {
+	mpmq.order = append(mpmq.order, o...)
+	return mpmq
+}
+
+// QueryProvider chains the current query on the "provider" edge.
+func (mpmq *ModelProviderModelQuery) QueryProvider() *ModelProviderQuery {
+	query := (&ModelProviderClient{config: mpmq.config}).Query()
+	query.path = func(ctx context.Context) (fromU *sql.Selector, err error) {
+		if err := mpmq.prepareQuery(ctx); err != nil {
+			return nil, err
+		}
+		selector := mpmq.sqlQuery(ctx)
+		if err := selector.Err(); err != nil {
+			return nil, err
+		}
+		step := sqlgraph.NewStep(
+			sqlgraph.From(modelprovidermodel.Table, modelprovidermodel.FieldID, selector),
+			sqlgraph.To(modelprovider.Table, modelprovider.FieldID),
+			sqlgraph.Edge(sqlgraph.M2O, true, modelprovidermodel.ProviderTable, modelprovidermodel.ProviderColumn),
+		)
+		fromU = sqlgraph.SetNeighbors(mpmq.driver.Dialect(), step)
+		return fromU, nil
+	}
+	return query
+}
+
+// First returns the first ModelProviderModel entity from the query.
+// Returns a *NotFoundError when no ModelProviderModel was found.
+func (mpmq *ModelProviderModelQuery) First(ctx context.Context) (*ModelProviderModel, error) {
+	nodes, err := mpmq.Limit(1).All(setContextOp(ctx, mpmq.ctx, ent.OpQueryFirst))
+	if err != nil {
+		return nil, err
+	}
+	if len(nodes) == 0 {
+		return nil, &NotFoundError{modelprovidermodel.Label}
+	}
+	return nodes[0], nil
+}
+
+// FirstX is like First, but panics if an error occurs.
+func (mpmq *ModelProviderModelQuery) FirstX(ctx context.Context) *ModelProviderModel {
+	node, err := mpmq.First(ctx)
+	if err != nil && !IsNotFound(err) {
+		panic(err)
+	}
+	return node
+}
+
+// FirstID returns the first ModelProviderModel ID from the query.
+// Returns a *NotFoundError when no ModelProviderModel ID was found.
+func (mpmq *ModelProviderModelQuery) FirstID(ctx context.Context) (id uuid.UUID, err error) {
+	var ids []uuid.UUID
+	if ids, err = mpmq.Limit(1).IDs(setContextOp(ctx, mpmq.ctx, ent.OpQueryFirstID)); err != nil {
+		return
+	}
+	if len(ids) == 0 {
+		err = &NotFoundError{modelprovidermodel.Label}
+		return
+	}
+	return ids[0], nil
+}
+
+// FirstIDX is like FirstID, but panics if an error occurs.
+func (mpmq *ModelProviderModelQuery) FirstIDX(ctx context.Context) uuid.UUID {
+	id, err := mpmq.FirstID(ctx)
+	if err != nil && !IsNotFound(err) {
+		panic(err)
+	}
+	return id
+}
+
+// Only returns a single ModelProviderModel entity found by the query, ensuring it only returns one.
+// Returns a *NotSingularError when more than one ModelProviderModel entity is found.
+// Returns a *NotFoundError when no ModelProviderModel entities are found.
+func (mpmq *ModelProviderModelQuery) Only(ctx context.Context) (*ModelProviderModel, error) {
+	nodes, err := mpmq.Limit(2).All(setContextOp(ctx, mpmq.ctx, ent.OpQueryOnly))
+	if err != nil {
+		return nil, err
+	}
+	switch len(nodes) {
+	case 1:
+		return nodes[0], nil
+	case 0:
+		return nil, &NotFoundError{modelprovidermodel.Label}
+	default:
+		return nil, &NotSingularError{modelprovidermodel.Label}
+	}
+}
+
+// OnlyX is like Only, but panics if an error occurs.
+func (mpmq *ModelProviderModelQuery) OnlyX(ctx context.Context) *ModelProviderModel {
+	node, err := mpmq.Only(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return node
+}
+
+// OnlyID is like Only, but returns the only ModelProviderModel ID in the query.
+// Returns a *NotSingularError when more than one ModelProviderModel ID is found.
+// Returns a *NotFoundError when no entities are found.
+func (mpmq *ModelProviderModelQuery) OnlyID(ctx context.Context) (id uuid.UUID, err error) {
+	var ids []uuid.UUID
+	if ids, err = mpmq.Limit(2).IDs(setContextOp(ctx, mpmq.ctx, ent.OpQueryOnlyID)); err != nil {
+		return
+	}
+	switch len(ids) {
+	case 1:
+		id = ids[0]
+	case 0:
+		err = &NotFoundError{modelprovidermodel.Label}
+	default:
+		err = &NotSingularError{modelprovidermodel.Label}
+	}
+	return
+}
+
+// OnlyIDX is like OnlyID, but panics if an error occurs.
+func (mpmq *ModelProviderModelQuery) OnlyIDX(ctx context.Context) uuid.UUID {
+	id, err := mpmq.OnlyID(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return id
+}
+
+// All executes the query and returns a list of ModelProviderModels.
+func (mpmq *ModelProviderModelQuery) All(ctx context.Context) ([]*ModelProviderModel, error) {
+	ctx = setContextOp(ctx, mpmq.ctx, ent.OpQueryAll)
+	if err := mpmq.prepareQuery(ctx); err != nil {
+		return nil, err
+	}
+	qr := querierAll[[]*ModelProviderModel, *ModelProviderModelQuery]()
+	return withInterceptors[[]*ModelProviderModel](ctx, mpmq, qr, mpmq.inters)
+}
+
+// AllX is like All, but panics if an error occurs.
+func (mpmq *ModelProviderModelQuery) AllX(ctx context.Context) []*ModelProviderModel {
+	nodes, err := mpmq.All(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return nodes
+}
+
+// IDs executes the query and returns a list of ModelProviderModel IDs.
+func (mpmq *ModelProviderModelQuery) IDs(ctx context.Context) (ids []uuid.UUID, err error) {
+	if mpmq.ctx.Unique == nil && mpmq.path != nil {
+		mpmq.Unique(true)
+	}
+	ctx = setContextOp(ctx, mpmq.ctx, ent.OpQueryIDs)
+	if err = mpmq.Select(modelprovidermodel.FieldID).Scan(ctx, &ids); err != nil {
+		return nil, err
+	}
+	return ids, nil
+}
+
+// IDsX is like IDs, but panics if an error occurs.
+func (mpmq *ModelProviderModelQuery) IDsX(ctx context.Context) []uuid.UUID {
+	ids, err := mpmq.IDs(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return ids
+}
+
+// Count returns the count of the given query.
+func (mpmq *ModelProviderModelQuery) Count(ctx context.Context) (int, error) {
+	ctx = setContextOp(ctx, mpmq.ctx, ent.OpQueryCount)
+	if err := mpmq.prepareQuery(ctx); err != nil {
+		return 0, err
+	}
+	return withInterceptors[int](ctx, mpmq, querierCount[*ModelProviderModelQuery](), mpmq.inters)
+}
+
+// CountX is like Count, but panics if an error occurs.
+func (mpmq *ModelProviderModelQuery) CountX(ctx context.Context) int {
+	count, err := mpmq.Count(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return count
+}
+
+// Exist returns true if the query has elements in the graph.
+func (mpmq *ModelProviderModelQuery) Exist(ctx context.Context) (bool, error) {
+	ctx = setContextOp(ctx, mpmq.ctx, ent.OpQueryExist)
+	switch _, err := mpmq.FirstID(ctx); {
+	case IsNotFound(err):
+		return false, nil
+	case err != nil:
+		return false, fmt.Errorf("db: check existence: %w", err)
+	default:
+		return true, nil
+	}
+}
+
+// ExistX is like Exist, but panics if an error occurs.
+func (mpmq *ModelProviderModelQuery) ExistX(ctx context.Context) bool {
+	exist, err := mpmq.Exist(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return exist
+}
+
+// Clone returns a duplicate of the ModelProviderModelQuery builder, including all associated steps. It can be
+// used to prepare common query builders and use them differently after the clone is made.
+func (mpmq *ModelProviderModelQuery) Clone() *ModelProviderModelQuery {
+	if mpmq == nil {
+		return nil
+	}
+	return &ModelProviderModelQuery{
+		config:       mpmq.config,
+		ctx:          mpmq.ctx.Clone(),
+		order:        append([]modelprovidermodel.OrderOption{}, mpmq.order...),
+		inters:       append([]Interceptor{}, mpmq.inters...),
+		predicates:   append([]predicate.ModelProviderModel{}, mpmq.predicates...),
+		withProvider: mpmq.withProvider.Clone(),
+		// clone intermediate query.
+		sql:       mpmq.sql.Clone(),
+		path:      mpmq.path,
+		modifiers: append([]func(*sql.Selector){}, mpmq.modifiers...),
+	}
+}
+
+// WithProvider tells the query-builder to eager-load the nodes that are connected to
+// the "provider" edge. The optional arguments are used to configure the query builder of the edge.
+func (mpmq *ModelProviderModelQuery) WithProvider(opts ...func(*ModelProviderQuery)) *ModelProviderModelQuery {
+	query := (&ModelProviderClient{config: mpmq.config}).Query()
+	for _, opt := range opts {
+		opt(query)
+	}
+	mpmq.withProvider = query
+	return mpmq
+}
+
+// GroupBy is used to group vertices by one or more fields/columns.
+// It is often used with aggregate functions, like: count, max, mean, min, sum.
+//
+// Example:
+//
+//	var v []struct {
+//		Name string `json:"name,omitempty"`
+//		Count int `json:"count,omitempty"`
+//	}
+//
+//	client.ModelProviderModel.Query().
+//		GroupBy(modelprovidermodel.FieldName).
+//		Aggregate(db.Count()).
+//		Scan(ctx, &v)
+func (mpmq *ModelProviderModelQuery) GroupBy(field string, fields ...string) *ModelProviderModelGroupBy {
+	mpmq.ctx.Fields = append([]string{field}, fields...)
+	grbuild := &ModelProviderModelGroupBy{build: mpmq}
+	grbuild.flds = &mpmq.ctx.Fields
+	grbuild.label = modelprovidermodel.Label
+	grbuild.scan = grbuild.Scan
+	return grbuild
+}
+
+// Select allows the selection one or more fields/columns for the given query,
+// instead of selecting all fields in the entity.
+//
+// Example:
+//
+//	var v []struct {
+//		Name string `json:"name,omitempty"`
+//	}
+//
+//	client.ModelProviderModel.Query().
+//		Select(modelprovidermodel.FieldName).
+//		Scan(ctx, &v)
+func (mpmq *ModelProviderModelQuery) Select(fields ...string) *ModelProviderModelSelect {
+	mpmq.ctx.Fields = append(mpmq.ctx.Fields, fields...)
+	sbuild := &ModelProviderModelSelect{ModelProviderModelQuery: mpmq}
+	sbuild.label = modelprovidermodel.Label
+	sbuild.flds, sbuild.scan = &mpmq.ctx.Fields, sbuild.Scan
+	return sbuild
+}
+
+// Aggregate returns a ModelProviderModelSelect configured with the given aggregations.
+func (mpmq *ModelProviderModelQuery) Aggregate(fns ...AggregateFunc) *ModelProviderModelSelect {
+	return mpmq.Select().Aggregate(fns...)
+}
+
+func (mpmq *ModelProviderModelQuery) prepareQuery(ctx context.Context) error {
+	for _, inter := range mpmq.inters {
+		if inter == nil {
+			return fmt.Errorf("db: uninitialized interceptor (forgotten import db/runtime?)")
+		}
+		if trv, ok := inter.(Traverser); ok {
+			if err := trv.Traverse(ctx, mpmq); err != nil {
+				return err
+			}
+		}
+	}
+	for _, f := range mpmq.ctx.Fields {
+		if !modelprovidermodel.ValidColumn(f) {
+			return &ValidationError{Name: f, err: fmt.Errorf("db: invalid field %q for query", f)}
+		}
+	}
+	if mpmq.path != nil {
+		prev, err := mpmq.path(ctx)
+		if err != nil {
+			return err
+		}
+		mpmq.sql = prev
+	}
+	return nil
+}
+
+func (mpmq *ModelProviderModelQuery) sqlAll(ctx context.Context, hooks ...queryHook) ([]*ModelProviderModel, error) {
+	var (
+		nodes       = []*ModelProviderModel{}
+		_spec       = mpmq.querySpec()
+		loadedTypes = [1]bool{
+			mpmq.withProvider != nil,
+		}
+	)
+	_spec.ScanValues = func(columns []string) ([]any, error) {
+		return (*ModelProviderModel).scanValues(nil, columns)
+	}
+	_spec.Assign = func(columns []string, values []any) error {
+		node := &ModelProviderModel{config: mpmq.config}
+		nodes = append(nodes, node)
+		node.Edges.loadedTypes = loadedTypes
+		return node.assignValues(columns, values)
+	}
+	if len(mpmq.modifiers) > 0 {
+		_spec.Modifiers = mpmq.modifiers
+	}
+	for i := range hooks {
+		hooks[i](ctx, _spec)
+	}
+	if err := sqlgraph.QueryNodes(ctx, mpmq.driver, _spec); err != nil {
+		return nil, err
+	}
+	if len(nodes) == 0 {
+		return nodes, nil
+	}
+	if query := mpmq.withProvider; query != nil {
+		if err := mpmq.loadProvider(ctx, query, nodes, nil,
+			func(n *ModelProviderModel, e *ModelProvider) { n.Edges.Provider = e }); err != nil {
+			return nil, err
+		}
+	}
+	return nodes, nil
+}
+
+func (mpmq *ModelProviderModelQuery) loadProvider(ctx context.Context, query *ModelProviderQuery, nodes []*ModelProviderModel, init func(*ModelProviderModel), assign func(*ModelProviderModel, *ModelProvider)) error {
+	ids := make([]string, 0, len(nodes))
+	nodeids := make(map[string][]*ModelProviderModel)
+	for i := range nodes {
+		fk := nodes[i].ProviderID
+		if _, ok := nodeids[fk]; !ok {
+			ids = append(ids, fk)
+		}
+		nodeids[fk] = append(nodeids[fk], nodes[i])
+	}
+	if len(ids) == 0 {
+		return nil
+	}
+	query.Where(modelprovider.IDIn(ids...))
+	neighbors, err := query.All(ctx)
+	if err != nil {
+		return err
+	}
+	for _, n := range neighbors {
+		nodes, ok := nodeids[n.ID]
+		if !ok {
+			return fmt.Errorf(`unexpected foreign-key "provider_id" returned %v`, n.ID)
+		}
+		for i := range nodes {
+			assign(nodes[i], n)
+		}
+	}
+	return nil
+}
+
+func (mpmq *ModelProviderModelQuery) sqlCount(ctx context.Context) (int, error) {
+	_spec := mpmq.querySpec()
+	if len(mpmq.modifiers) > 0 {
+		_spec.Modifiers = mpmq.modifiers
+	}
+	_spec.Node.Columns = mpmq.ctx.Fields
+	if len(mpmq.ctx.Fields) > 0 {
+		_spec.Unique = mpmq.ctx.Unique != nil && *mpmq.ctx.Unique
+	}
+	return sqlgraph.CountNodes(ctx, mpmq.driver, _spec)
+}
+
+func (mpmq *ModelProviderModelQuery) querySpec() *sqlgraph.QuerySpec {
+	_spec := sqlgraph.NewQuerySpec(modelprovidermodel.Table, modelprovidermodel.Columns, sqlgraph.NewFieldSpec(modelprovidermodel.FieldID, field.TypeUUID))
+	_spec.From = mpmq.sql
+	if unique := mpmq.ctx.Unique; unique != nil {
+		_spec.Unique = *unique
+	} else if mpmq.path != nil {
+		_spec.Unique = true
+	}
+	if fields := mpmq.ctx.Fields; len(fields) > 0 {
+		_spec.Node.Columns = make([]string, 0, len(fields))
+		_spec.Node.Columns = append(_spec.Node.Columns, modelprovidermodel.FieldID)
+		for i := range fields {
+			if fields[i] != modelprovidermodel.FieldID {
+				_spec.Node.Columns = append(_spec.Node.Columns, fields[i])
+			}
+		}
+		if mpmq.withProvider != nil {
+			_spec.Node.AddColumnOnce(modelprovidermodel.FieldProviderID)
+		}
+	}
+	if ps := mpmq.predicates; len(ps) > 0 {
+		_spec.Predicate = func(selector *sql.Selector) {
+			for i := range ps {
+				ps[i](selector)
+			}
+		}
+	}
+	if limit := mpmq.ctx.Limit; limit != nil {
+		_spec.Limit = *limit
+	}
+	if offset := mpmq.ctx.Offset; offset != nil {
+		_spec.Offset = *offset
+	}
+	if ps := mpmq.order; len(ps) > 0 {
+		_spec.Order = func(selector *sql.Selector) {
+			for i := range ps {
+				ps[i](selector)
+			}
+		}
+	}
+	return _spec
+}
+
+func (mpmq *ModelProviderModelQuery) sqlQuery(ctx context.Context) *sql.Selector {
+	builder := sql.Dialect(mpmq.driver.Dialect())
+	t1 := builder.Table(modelprovidermodel.Table)
+	columns := mpmq.ctx.Fields
+	if len(columns) == 0 {
+		columns = modelprovidermodel.Columns
+	}
+	selector := builder.Select(t1.Columns(columns...)...).From(t1)
+	if mpmq.sql != nil {
+		selector = mpmq.sql
+		selector.Select(selector.Columns(columns...)...)
+	}
+	if mpmq.ctx.Unique != nil && *mpmq.ctx.Unique {
+		selector.Distinct()
+	}
+	for _, m := range mpmq.modifiers {
+		m(selector)
+	}
+	for _, p := range mpmq.predicates {
+		p(selector)
+	}
+	for _, p := range mpmq.order {
+		p(selector)
+	}
+	if offset := mpmq.ctx.Offset; offset != nil {
+		// limit is mandatory for offset clause. We start
+		// with default value, and override it below if needed.
+		selector.Offset(*offset).Limit(math.MaxInt32)
+	}
+	if limit := mpmq.ctx.Limit; limit != nil {
+		selector.Limit(*limit)
+	}
+	return selector
+}
+
+// ForUpdate locks the selected rows against concurrent updates, and prevent them from being
+// updated, deleted or "selected ... for update" by other sessions, until the transaction is
+// either committed or rolled-back.
+func (mpmq *ModelProviderModelQuery) ForUpdate(opts ...sql.LockOption) *ModelProviderModelQuery {
+	if mpmq.driver.Dialect() == dialect.Postgres {
+		mpmq.Unique(false)
+	}
+	mpmq.modifiers = append(mpmq.modifiers, func(s *sql.Selector) {
+		s.ForUpdate(opts...)
+	})
+	return mpmq
+}
+
+// ForShare behaves similarly to ForUpdate, except that it acquires a shared mode lock
+// on any rows that are read. Other sessions can read the rows, but cannot modify them
+// until your transaction commits.
+func (mpmq *ModelProviderModelQuery) ForShare(opts ...sql.LockOption) *ModelProviderModelQuery {
+	if mpmq.driver.Dialect() == dialect.Postgres {
+		mpmq.Unique(false)
+	}
+	mpmq.modifiers = append(mpmq.modifiers, func(s *sql.Selector) {
+		s.ForShare(opts...)
+	})
+	return mpmq
+}
+
+// Modify adds a query modifier for attaching custom logic to queries.
+func (mpmq *ModelProviderModelQuery) Modify(modifiers ...func(s *sql.Selector)) *ModelProviderModelSelect {
+	mpmq.modifiers = append(mpmq.modifiers, modifiers...)
+	return mpmq.Select()
+}
+
+// ModelProviderModelGroupBy is the group-by builder for ModelProviderModel entities.
+type ModelProviderModelGroupBy struct {
+	selector
+	build *ModelProviderModelQuery
+}
+
+// Aggregate adds the given aggregation functions to the group-by query.
+func (mpmgb *ModelProviderModelGroupBy) Aggregate(fns ...AggregateFunc) *ModelProviderModelGroupBy {
+	mpmgb.fns = append(mpmgb.fns, fns...)
+	return mpmgb
+}
+
+// Scan applies the selector query and scans the result into the given value.
+func (mpmgb *ModelProviderModelGroupBy) Scan(ctx context.Context, v any) error {
+	ctx = setContextOp(ctx, mpmgb.build.ctx, ent.OpQueryGroupBy)
+	if err := mpmgb.build.prepareQuery(ctx); err != nil {
+		return err
+	}
+	return scanWithInterceptors[*ModelProviderModelQuery, *ModelProviderModelGroupBy](ctx, mpmgb.build, mpmgb, mpmgb.build.inters, v)
+}
+
+func (mpmgb *ModelProviderModelGroupBy) sqlScan(ctx context.Context, root *ModelProviderModelQuery, v any) error {
+	selector := root.sqlQuery(ctx).Select()
+	aggregation := make([]string, 0, len(mpmgb.fns))
+	for _, fn := range mpmgb.fns {
+		aggregation = append(aggregation, fn(selector))
+	}
+	if len(selector.SelectedColumns()) == 0 {
+		columns := make([]string, 0, len(*mpmgb.flds)+len(mpmgb.fns))
+		for _, f := range *mpmgb.flds {
+			columns = append(columns, selector.C(f))
+		}
+		columns = append(columns, aggregation...)
+		selector.Select(columns...)
+	}
+	selector.GroupBy(selector.Columns(*mpmgb.flds...)...)
+	if err := selector.Err(); err != nil {
+		return err
+	}
+	rows := &sql.Rows{}
+	query, args := selector.Query()
+	if err := mpmgb.build.driver.Query(ctx, query, args, rows); err != nil {
+		return err
+	}
+	defer rows.Close()
+	return sql.ScanSlice(rows, v)
+}
+
+// ModelProviderModelSelect is the builder for selecting fields of ModelProviderModel entities.
+type ModelProviderModelSelect struct {
+	*ModelProviderModelQuery
+	selector
+}
+
+// Aggregate adds the given aggregation functions to the selector query.
+func (mpms *ModelProviderModelSelect) Aggregate(fns ...AggregateFunc) *ModelProviderModelSelect {
+	mpms.fns = append(mpms.fns, fns...)
+	return mpms
+}
+
+// Scan applies the selector query and scans the result into the given value.
+func (mpms *ModelProviderModelSelect) Scan(ctx context.Context, v any) error {
+	ctx = setContextOp(ctx, mpms.ctx, ent.OpQuerySelect)
+	if err := mpms.prepareQuery(ctx); err != nil {
+		return err
+	}
+	return scanWithInterceptors[*ModelProviderModelQuery, *ModelProviderModelSelect](ctx, mpms.ModelProviderModelQuery, mpms, mpms.inters, v)
+}
+
+func (mpms *ModelProviderModelSelect) sqlScan(ctx context.Context, root *ModelProviderModelQuery, v any) error {
+	selector := root.sqlQuery(ctx)
+	aggregation := make([]string, 0, len(mpms.fns))
+	for _, fn := range mpms.fns {
+		aggregation = append(aggregation, fn(selector))
+	}
+	switch n := len(*mpms.selector.flds); {
+	case n == 0 && len(aggregation) > 0:
+		selector.Select(aggregation...)
+	case n != 0 && len(aggregation) > 0:
+		selector.AppendSelect(aggregation...)
+	}
+	rows := &sql.Rows{}
+	query, args := selector.Query()
+	if err := mpms.driver.Query(ctx, query, args, rows); err != nil {
+		return err
+	}
+	defer rows.Close()
+	return sql.ScanSlice(rows, v)
+}
+
+// Modify adds a query modifier for attaching custom logic to queries.
+func (mpms *ModelProviderModelSelect) Modify(modifiers ...func(s *sql.Selector)) *ModelProviderModelSelect {
+	mpms.modifiers = append(mpms.modifiers, modifiers...)
+	return mpms
+}

backend/db/modelprovidermodel_update.go

@@ -0,0 +1,443 @@
+// Code generated by ent, DO NOT EDIT.
+
+package db
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"time"
+
+	"entgo.io/ent/dialect/sql"
+	"entgo.io/ent/dialect/sql/sqlgraph"
+	"entgo.io/ent/schema/field"
+	"github.com/chaitin/MonkeyCode/backend/db/modelprovider"
+	"github.com/chaitin/MonkeyCode/backend/db/modelprovidermodel"
+	"github.com/chaitin/MonkeyCode/backend/db/predicate"
+)
+
+// ModelProviderModelUpdate is the builder for updating ModelProviderModel entities.
+type ModelProviderModelUpdate struct {
+	config
+	hooks     []Hook
+	mutation  *ModelProviderModelMutation
+	modifiers []func(*sql.UpdateBuilder)
+}
+
+// Where appends a list predicates to the ModelProviderModelUpdate builder.
+func (mpmu *ModelProviderModelUpdate) Where(ps ...predicate.ModelProviderModel) *ModelProviderModelUpdate {
+	mpmu.mutation.Where(ps...)
+	return mpmu
+}
+
+// SetName sets the "name" field.
+func (mpmu *ModelProviderModelUpdate) SetName(s string) *ModelProviderModelUpdate {
+	mpmu.mutation.SetName(s)
+	return mpmu
+}
+
+// SetNillableName sets the "name" field if the given value is not nil.
+func (mpmu *ModelProviderModelUpdate) SetNillableName(s *string) *ModelProviderModelUpdate {
+	if s != nil {
+		mpmu.SetName(*s)
+	}
+	return mpmu
+}
+
+// SetProviderID sets the "provider_id" field.
+func (mpmu *ModelProviderModelUpdate) SetProviderID(s string) *ModelProviderModelUpdate {
+	mpmu.mutation.SetProviderID(s)
+	return mpmu
+}
+
+// SetNillableProviderID sets the "provider_id" field if the given value is not nil.
+func (mpmu *ModelProviderModelUpdate) SetNillableProviderID(s *string) *ModelProviderModelUpdate {
+	if s != nil {
+		mpmu.SetProviderID(*s)
+	}
+	return mpmu
+}
+
+// ClearProviderID clears the value of the "provider_id" field.
+func (mpmu *ModelProviderModelUpdate) ClearProviderID() *ModelProviderModelUpdate {
+	mpmu.mutation.ClearProviderID()
+	return mpmu
+}
+
+// SetCreatedAt sets the "created_at" field.
+func (mpmu *ModelProviderModelUpdate) SetCreatedAt(t time.Time) *ModelProviderModelUpdate {
+	mpmu.mutation.SetCreatedAt(t)
+	return mpmu
+}
+
+// SetNillableCreatedAt sets the "created_at" field if the given value is not nil.
+func (mpmu *ModelProviderModelUpdate) SetNillableCreatedAt(t *time.Time) *ModelProviderModelUpdate {
+	if t != nil {
+		mpmu.SetCreatedAt(*t)
+	}
+	return mpmu
+}
+
+// SetUpdatedAt sets the "updated_at" field.
+func (mpmu *ModelProviderModelUpdate) SetUpdatedAt(t time.Time) *ModelProviderModelUpdate {
+	mpmu.mutation.SetUpdatedAt(t)
+	return mpmu
+}
+
+// SetProvider sets the "provider" edge to the ModelProvider entity.
+func (mpmu *ModelProviderModelUpdate) SetProvider(m *ModelProvider) *ModelProviderModelUpdate {
+	return mpmu.SetProviderID(m.ID)
+}
+
+// Mutation returns the ModelProviderModelMutation object of the builder.
+func (mpmu *ModelProviderModelUpdate) Mutation() *ModelProviderModelMutation {
+	return mpmu.mutation
+}
+
+// ClearProvider clears the "provider" edge to the ModelProvider entity.
+func (mpmu *ModelProviderModelUpdate) ClearProvider() *ModelProviderModelUpdate {
+	mpmu.mutation.ClearProvider()
+	return mpmu
+}
+
+// Save executes the query and returns the number of nodes affected by the update operation.
+func (mpmu *ModelProviderModelUpdate) Save(ctx context.Context) (int, error) {
+	mpmu.defaults()
+	return withHooks(ctx, mpmu.sqlSave, mpmu.mutation, mpmu.hooks)
+}
+
+// SaveX is like Save, but panics if an error occurs.
+func (mpmu *ModelProviderModelUpdate) SaveX(ctx context.Context) int {
+	affected, err := mpmu.Save(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return affected
+}
+
+// Exec executes the query.
+func (mpmu *ModelProviderModelUpdate) Exec(ctx context.Context) error {
+	_, err := mpmu.Save(ctx)
+	return err
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (mpmu *ModelProviderModelUpdate) ExecX(ctx context.Context) {
+	if err := mpmu.Exec(ctx); err != nil {
+		panic(err)
+	}
+}
+
+// defaults sets the default values of the builder before save.
+func (mpmu *ModelProviderModelUpdate) defaults() {
+	if _, ok := mpmu.mutation.UpdatedAt(); !ok {
+		v := modelprovidermodel.UpdateDefaultUpdatedAt()
+		mpmu.mutation.SetUpdatedAt(v)
+	}
+}
+
+// check runs all checks and user-defined validators on the builder.
+func (mpmu *ModelProviderModelUpdate) check() error {
+	if v, ok := mpmu.mutation.Name(); ok {
+		if err := modelprovidermodel.NameValidator(v); err != nil {
+			return &ValidationError{Name: "name", err: fmt.Errorf(`db: validator failed for field "ModelProviderModel.name": %w`, err)}
+		}
+	}
+	return nil
+}
+
+// Modify adds a statement modifier for attaching custom logic to the UPDATE statement.
+func (mpmu *ModelProviderModelUpdate) Modify(modifiers ...func(u *sql.UpdateBuilder)) *ModelProviderModelUpdate {
+	mpmu.modifiers = append(mpmu.modifiers, modifiers...)
+	return mpmu
+}
+
+func (mpmu *ModelProviderModelUpdate) sqlSave(ctx context.Context) (n int, err error) {
+	if err := mpmu.check(); err != nil {
+		return n, err
+	}
+	_spec := sqlgraph.NewUpdateSpec(modelprovidermodel.Table, modelprovidermodel.Columns, sqlgraph.NewFieldSpec(modelprovidermodel.FieldID, field.TypeUUID))
+	if ps := mpmu.mutation.predicates; len(ps) > 0 {
+		_spec.Predicate = func(selector *sql.Selector) {
+			for i := range ps {
+				ps[i](selector)
+			}
+		}
+	}
+	if value, ok := mpmu.mutation.Name(); ok {
+		_spec.SetField(modelprovidermodel.FieldName, field.TypeString, value)
+	}
+	if value, ok := mpmu.mutation.CreatedAt(); ok {
+		_spec.SetField(modelprovidermodel.FieldCreatedAt, field.TypeTime, value)
+	}
+	if value, ok := mpmu.mutation.UpdatedAt(); ok {
+		_spec.SetField(modelprovidermodel.FieldUpdatedAt, field.TypeTime, value)
+	}
+	if mpmu.mutation.ProviderCleared() {
+		edge := &sqlgraph.EdgeSpec{
+			Rel:     sqlgraph.M2O,
+			Inverse: true,
+			Table:   modelprovidermodel.ProviderTable,
+			Columns: []string{modelprovidermodel.ProviderColumn},
+			Bidi:    false,
+			Target: &sqlgraph.EdgeTarget{
+				IDSpec: sqlgraph.NewFieldSpec(modelprovider.FieldID, field.TypeString),
+			},
+		}
+		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
+	}
+	if nodes := mpmu.mutation.ProviderIDs(); len(nodes) > 0 {
+		edge := &sqlgraph.EdgeSpec{
+			Rel:     sqlgraph.M2O,
+			Inverse: true,
+			Table:   modelprovidermodel.ProviderTable,
+			Columns: []string{modelprovidermodel.ProviderColumn},
+			Bidi:    false,
+			Target: &sqlgraph.EdgeTarget{
+				IDSpec: sqlgraph.NewFieldSpec(modelprovider.FieldID, field.TypeString),
+			},
+		}
+		for _, k := range nodes {
+			edge.Target.Nodes = append(edge.Target.Nodes, k)
+		}
+		_spec.Edges.Add = append(_spec.Edges.Add, edge)
+	}
+	_spec.AddModifiers(mpmu.modifiers...)
+	if n, err = sqlgraph.UpdateNodes(ctx, mpmu.driver, _spec); err != nil {
+		if _, ok := err.(*sqlgraph.NotFoundError); ok {
+			err = &NotFoundError{modelprovidermodel.Label}
+		} else if sqlgraph.IsConstraintError(err) {
+			err = &ConstraintError{msg: err.Error(), wrap: err}
+		}
+		return 0, err
+	}
+	mpmu.mutation.done = true
+	return n, nil
+}
+
+// ModelProviderModelUpdateOne is the builder for updating a single ModelProviderModel entity.
+type ModelProviderModelUpdateOne struct {
+	config
+	fields    []string
+	hooks     []Hook
+	mutation  *ModelProviderModelMutation
+	modifiers []func(*sql.UpdateBuilder)
+}
+
+// SetName sets the "name" field.
+func (mpmuo *ModelProviderModelUpdateOne) SetName(s string) *ModelProviderModelUpdateOne {
+	mpmuo.mutation.SetName(s)
+	return mpmuo
+}
+
+// SetNillableName sets the "name" field if the given value is not nil.
+func (mpmuo *ModelProviderModelUpdateOne) SetNillableName(s *string) *ModelProviderModelUpdateOne {
+	if s != nil {
+		mpmuo.SetName(*s)
+	}
+	return mpmuo
+}
+
+// SetProviderID sets the "provider_id" field.
+func (mpmuo *ModelProviderModelUpdateOne) SetProviderID(s string) *ModelProviderModelUpdateOne {
+	mpmuo.mutation.SetProviderID(s)
+	return mpmuo
+}
+
+// SetNillableProviderID sets the "provider_id" field if the given value is not nil.
+func (mpmuo *ModelProviderModelUpdateOne) SetNillableProviderID(s *string) *ModelProviderModelUpdateOne {
+	if s != nil {
+		mpmuo.SetProviderID(*s)
+	}
+	return mpmuo
+}
+
+// ClearProviderID clears the value of the "provider_id" field.
+func (mpmuo *ModelProviderModelUpdateOne) ClearProviderID() *ModelProviderModelUpdateOne {
+	mpmuo.mutation.ClearProviderID()
+	return mpmuo
+}
+
+// SetCreatedAt sets the "created_at" field.
+func (mpmuo *ModelProviderModelUpdateOne) SetCreatedAt(t time.Time) *ModelProviderModelUpdateOne {
+	mpmuo.mutation.SetCreatedAt(t)
+	return mpmuo
+}
+
+// SetNillableCreatedAt sets the "created_at" field if the given value is not nil.
+func (mpmuo *ModelProviderModelUpdateOne) SetNillableCreatedAt(t *time.Time) *ModelProviderModelUpdateOne {
+	if t != nil {
+		mpmuo.SetCreatedAt(*t)
+	}
+	return mpmuo
+}
+
+// SetUpdatedAt sets the "updated_at" field.
+func (mpmuo *ModelProviderModelUpdateOne) SetUpdatedAt(t time.Time) *ModelProviderModelUpdateOne {
+	mpmuo.mutation.SetUpdatedAt(t)
+	return mpmuo
+}
+
+// SetProvider sets the "provider" edge to the ModelProvider entity.
+func (mpmuo *ModelProviderModelUpdateOne) SetProvider(m *ModelProvider) *ModelProviderModelUpdateOne {
+	return mpmuo.SetProviderID(m.ID)
+}
+
+// Mutation returns the ModelProviderModelMutation object of the builder.
+func (mpmuo *ModelProviderModelUpdateOne) Mutation() *ModelProviderModelMutation {
+	return mpmuo.mutation
+}
+
+// ClearProvider clears the "provider" edge to the ModelProvider entity.
+func (mpmuo *ModelProviderModelUpdateOne) ClearProvider() *ModelProviderModelUpdateOne {
+	mpmuo.mutation.ClearProvider()
+	return mpmuo
+}
+
+// Where appends a list predicates to the ModelProviderModelUpdate builder.
+func (mpmuo *ModelProviderModelUpdateOne) Where(ps ...predicate.ModelProviderModel) *ModelProviderModelUpdateOne {
+	mpmuo.mutation.Where(ps...)
+	return mpmuo
+}
+
+// Select allows selecting one or more fields (columns) of the returned entity.
+// The default is selecting all fields defined in the entity schema.
+func (mpmuo *ModelProviderModelUpdateOne) Select(field string, fields ...string) *ModelProviderModelUpdateOne {
+	mpmuo.fields = append([]string{field}, fields...)
+	return mpmuo
+}
+
+// Save executes the query and returns the updated ModelProviderModel entity.
+func (mpmuo *ModelProviderModelUpdateOne) Save(ctx context.Context) (*ModelProviderModel, error) {
+	mpmuo.defaults()
+	return withHooks(ctx, mpmuo.sqlSave, mpmuo.mutation, mpmuo.hooks)
+}
+
+// SaveX is like Save, but panics if an error occurs.
+func (mpmuo *ModelProviderModelUpdateOne) SaveX(ctx context.Context) *ModelProviderModel {
+	node, err := mpmuo.Save(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return node
+}
+
+// Exec executes the query on the entity.
+func (mpmuo *ModelProviderModelUpdateOne) Exec(ctx context.Context) error {
+	_, err := mpmuo.Save(ctx)
+	return err
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (mpmuo *ModelProviderModelUpdateOne) ExecX(ctx context.Context) {
+	if err := mpmuo.Exec(ctx); err != nil {
+		panic(err)
+	}
+}
+
+// defaults sets the default values of the builder before save.
+func (mpmuo *ModelProviderModelUpdateOne) defaults() {
+	if _, ok := mpmuo.mutation.UpdatedAt(); !ok {
+		v := modelprovidermodel.UpdateDefaultUpdatedAt()
+		mpmuo.mutation.SetUpdatedAt(v)
+	}
+}
+
+// check runs all checks and user-defined validators on the builder.
+func (mpmuo *ModelProviderModelUpdateOne) check() error {
+	if v, ok := mpmuo.mutation.Name(); ok {
+		if err := modelprovidermodel.NameValidator(v); err != nil {
+			return &ValidationError{Name: "name", err: fmt.Errorf(`db: validator failed for field "ModelProviderModel.name": %w`, err)}
+		}
+	}
+	return nil
+}
+
+// Modify adds a statement modifier for attaching custom logic to the UPDATE statement.
+func (mpmuo *ModelProviderModelUpdateOne) Modify(modifiers ...func(u *sql.UpdateBuilder)) *ModelProviderModelUpdateOne {
+	mpmuo.modifiers = append(mpmuo.modifiers, modifiers...)
+	return mpmuo
+}
+
+func (mpmuo *ModelProviderModelUpdateOne) sqlSave(ctx context.Context) (_node *ModelProviderModel, err error) {
+	if err := mpmuo.check(); err != nil {
+		return _node, err
+	}
+	_spec := sqlgraph.NewUpdateSpec(modelprovidermodel.Table, modelprovidermodel.Columns, sqlgraph.NewFieldSpec(modelprovidermodel.FieldID, field.TypeUUID))
+	id, ok := mpmuo.mutation.ID()
+	if !ok {
+		return nil, &ValidationError{Name: "id", err: errors.New(`db: missing "ModelProviderModel.id" for update`)}
+	}
+	_spec.Node.ID.Value = id
+	if fields := mpmuo.fields; len(fields) > 0 {
+		_spec.Node.Columns = make([]string, 0, len(fields))
+		_spec.Node.Columns = append(_spec.Node.Columns, modelprovidermodel.FieldID)
+		for _, f := range fields {
+			if !modelprovidermodel.ValidColumn(f) {
+				return nil, &ValidationError{Name: f, err: fmt.Errorf("db: invalid field %q for query", f)}
+			}
+			if f != modelprovidermodel.FieldID {
+				_spec.Node.Columns = append(_spec.Node.Columns, f)
+			}
+		}
+	}
+	if ps := mpmuo.mutation.predicates; len(ps) > 0 {
+		_spec.Predicate = func(selector *sql.Selector) {
+			for i := range ps {
+				ps[i](selector)
+			}
+		}
+	}
+	if value, ok := mpmuo.mutation.Name(); ok {
+		_spec.SetField(modelprovidermodel.FieldName, field.TypeString, value)
+	}
+	if value, ok := mpmuo.mutation.CreatedAt(); ok {
+		_spec.SetField(modelprovidermodel.FieldCreatedAt, field.TypeTime, value)
+	}
+	if value, ok := mpmuo.mutation.UpdatedAt(); ok {
+		_spec.SetField(modelprovidermodel.FieldUpdatedAt, field.TypeTime, value)
+	}
+	if mpmuo.mutation.ProviderCleared() {
+		edge := &sqlgraph.EdgeSpec{
+			Rel:     sqlgraph.M2O,
+			Inverse: true,
+			Table:   modelprovidermodel.ProviderTable,
+			Columns: []string{modelprovidermodel.ProviderColumn},
+			Bidi:    false,
+			Target: &sqlgraph.EdgeTarget{
+				IDSpec: sqlgraph.NewFieldSpec(modelprovider.FieldID, field.TypeString),
+			},
+		}
+		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
+	}
+	if nodes := mpmuo.mutation.ProviderIDs(); len(nodes) > 0 {
+		edge := &sqlgraph.EdgeSpec{
+			Rel:     sqlgraph.M2O,
+			Inverse: true,
+			Table:   modelprovidermodel.ProviderTable,
+			Columns: []string{modelprovidermodel.ProviderColumn},
+			Bidi:    false,
+			Target: &sqlgraph.EdgeTarget{
+				IDSpec: sqlgraph.NewFieldSpec(modelprovider.FieldID, field.TypeString),
+			},
+		}
+		for _, k := range nodes {
+			edge.Target.Nodes = append(edge.Target.Nodes, k)
+		}
+		_spec.Edges.Add = append(_spec.Edges.Add, edge)
+	}
+	_spec.AddModifiers(mpmuo.modifiers...)
+	_node = &ModelProviderModel{config: mpmuo.config}
+	_spec.Assign = _node.assignValues
+	_spec.ScanValues = _node.scanValues
+	if err = sqlgraph.UpdateNode(ctx, mpmuo.driver, _spec); err != nil {
+		if _, ok := err.(*sqlgraph.NotFoundError); ok {
+			err = &NotFoundError{modelprovidermodel.Label}
+		} else if sqlgraph.IsConstraintError(err) {
+			err = &ConstraintError{msg: err.Error(), wrap: err}
+		}
+		return nil, err
+	}
+	mpmuo.mutation.done = true
+	return _node, nil
+}

backend/db/page.go

@@ -137,6 +137,34 @@ func (m *ModelQuery) Page(ctx context.Context, page, size int) ([]*Model, *PageI
 	return rs, &PageInfo{HasNextPage: has, TotalCount: int64(cnt)}, nil
 }
 
+func (mp *ModelProviderQuery) Page(ctx context.Context, page, size int) ([]*ModelProvider, *PageInfo, error) {
+	cnt, err := mp.Count(ctx)
+	if err != nil {
+		return nil, nil, err
+	}
+	offset := size * (page - 1)
+	rs, err := mp.Offset(offset).Limit(size).All(ctx)
+	if err != nil {
+		return nil, nil, err
+	}
+	has := (page * size) < cnt
+	return rs, &PageInfo{HasNextPage: has, TotalCount: int64(cnt)}, nil
+}
+
+func (mpm *ModelProviderModelQuery) Page(ctx context.Context, page, size int) ([]*ModelProviderModel, *PageInfo, error) {
+	cnt, err := mpm.Count(ctx)
+	if err != nil {
+		return nil, nil, err
+	}
+	offset := size * (page - 1)
+	rs, err := mpm.Offset(offset).Limit(size).All(ctx)
+	if err != nil {
+		return nil, nil, err
+	}
+	has := (page * size) < cnt
+	return rs, &PageInfo{HasNextPage: has, TotalCount: int64(cnt)}, nil
+}
+
 func (s *SettingQuery) Page(ctx context.Context, page, size int) ([]*Setting, *PageInfo, error) {
 	cnt, err := s.Count(ctx)
 	if err != nil {

backend/db/predicate/predicate.go

@@ -33,6 +33,12 @@ type InviteCode func(*sql.Selector)
 // Model is the predicate function for model builders.
 type Model func(*sql.Selector)
 
+// ModelProvider is the predicate function for modelprovider builders.
+type ModelProvider func(*sql.Selector)
+
+// ModelProviderModel is the predicate function for modelprovidermodel builders.
+type ModelProviderModel func(*sql.Selector)
+
 // Setting is the predicate function for setting builders.
 type Setting func(*sql.Selector)
 

backend/db/runtime/runtime.go

@@ -15,6 +15,8 @@ import (
 	"github.com/chaitin/MonkeyCode/backend/db/billingusage"
 	"github.com/chaitin/MonkeyCode/backend/db/invitecode"
 	"github.com/chaitin/MonkeyCode/backend/db/model"
+	"github.com/chaitin/MonkeyCode/backend/db/modelprovider"
+	"github.com/chaitin/MonkeyCode/backend/db/modelprovidermodel"
 	"github.com/chaitin/MonkeyCode/backend/db/setting"
 	"github.com/chaitin/MonkeyCode/backend/db/task"
 	"github.com/chaitin/MonkeyCode/backend/db/taskrecord"
@@ -22,6 +24,7 @@ import (
 	"github.com/chaitin/MonkeyCode/backend/db/useridentity"
 	"github.com/chaitin/MonkeyCode/backend/db/userloginhistory"
 	"github.com/chaitin/MonkeyCode/backend/ent/schema"
+	"github.com/google/uuid"
 )
 
 // The init function reads all schema descriptors with runtime code
@@ -156,6 +159,54 @@ func init() {
 	model.DefaultUpdatedAt = modelDescUpdatedAt.Default.(func() time.Time)
 	// model.UpdateDefaultUpdatedAt holds the default value on update for the updated_at field.
 	model.UpdateDefaultUpdatedAt = modelDescUpdatedAt.UpdateDefault.(func() time.Time)
+	modelproviderFields := schema.ModelProvider{}.Fields()
+	_ = modelproviderFields
+	// modelproviderDescName is the schema descriptor for name field.
+	modelproviderDescName := modelproviderFields[1].Descriptor()
+	// modelprovider.NameValidator is a validator for the "name" field. It is called by the builders before save.
+	modelprovider.NameValidator = modelproviderDescName.Validators[0].(func(string) error)
+	// modelproviderDescAPIBase is the schema descriptor for api_base field.
+	modelproviderDescAPIBase := modelproviderFields[2].Descriptor()
+	// modelprovider.APIBaseValidator is a validator for the "api_base" field. It is called by the builders before save.
+	modelprovider.APIBaseValidator = modelproviderDescAPIBase.Validators[0].(func(string) error)
+	// modelproviderDescPriority is the schema descriptor for priority field.
+	modelproviderDescPriority := modelproviderFields[3].Descriptor()
+	// modelprovider.DefaultPriority holds the default value on creation for the priority field.
+	modelprovider.DefaultPriority = modelproviderDescPriority.Default.(int)
+	// modelproviderDescCreatedAt is the schema descriptor for created_at field.
+	modelproviderDescCreatedAt := modelproviderFields[4].Descriptor()
+	// modelprovider.DefaultCreatedAt holds the default value on creation for the created_at field.
+	modelprovider.DefaultCreatedAt = modelproviderDescCreatedAt.Default.(func() time.Time)
+	// modelproviderDescUpdatedAt is the schema descriptor for updated_at field.
+	modelproviderDescUpdatedAt := modelproviderFields[5].Descriptor()
+	// modelprovider.DefaultUpdatedAt holds the default value on creation for the updated_at field.
+	modelprovider.DefaultUpdatedAt = modelproviderDescUpdatedAt.Default.(func() time.Time)
+	// modelprovider.UpdateDefaultUpdatedAt holds the default value on update for the updated_at field.
+	modelprovider.UpdateDefaultUpdatedAt = modelproviderDescUpdatedAt.UpdateDefault.(func() time.Time)
+	// modelproviderDescID is the schema descriptor for id field.
+	modelproviderDescID := modelproviderFields[0].Descriptor()
+	// modelprovider.IDValidator is a validator for the "id" field. It is called by the builders before save.
+	modelprovider.IDValidator = modelproviderDescID.Validators[0].(func(string) error)
+	modelprovidermodelFields := schema.ModelProviderModel{}.Fields()
+	_ = modelprovidermodelFields
+	// modelprovidermodelDescName is the schema descriptor for name field.
+	modelprovidermodelDescName := modelprovidermodelFields[1].Descriptor()
+	// modelprovidermodel.NameValidator is a validator for the "name" field. It is called by the builders before save.
+	modelprovidermodel.NameValidator = modelprovidermodelDescName.Validators[0].(func(string) error)
+	// modelprovidermodelDescCreatedAt is the schema descriptor for created_at field.
+	modelprovidermodelDescCreatedAt := modelprovidermodelFields[3].Descriptor()
+	// modelprovidermodel.DefaultCreatedAt holds the default value on creation for the created_at field.
+	modelprovidermodel.DefaultCreatedAt = modelprovidermodelDescCreatedAt.Default.(func() time.Time)
+	// modelprovidermodelDescUpdatedAt is the schema descriptor for updated_at field.
+	modelprovidermodelDescUpdatedAt := modelprovidermodelFields[4].Descriptor()
+	// modelprovidermodel.DefaultUpdatedAt holds the default value on creation for the updated_at field.
+	modelprovidermodel.DefaultUpdatedAt = modelprovidermodelDescUpdatedAt.Default.(func() time.Time)
+	// modelprovidermodel.UpdateDefaultUpdatedAt holds the default value on update for the updated_at field.
+	modelprovidermodel.UpdateDefaultUpdatedAt = modelprovidermodelDescUpdatedAt.UpdateDefault.(func() time.Time)
+	// modelprovidermodelDescID is the schema descriptor for id field.
+	modelprovidermodelDescID := modelprovidermodelFields[0].Descriptor()
+	// modelprovidermodel.DefaultID holds the default value on creation for the id field.
+	modelprovidermodel.DefaultID = modelprovidermodelDescID.Default.(func() uuid.UUID)
 	settingFields := schema.Setting{}.Fields()
 	_ = settingFields
 	// settingDescEnableSSO is the schema descriptor for enable_sso field.

backend/db/tx.go

@@ -32,6 +32,10 @@ type Tx struct {
 	InviteCode *InviteCodeClient
 	// Model is the client for interacting with the Model builders.
 	Model *ModelClient
+	// ModelProvider is the client for interacting with the ModelProvider builders.
+	ModelProvider *ModelProviderClient
+	// ModelProviderModel is the client for interacting with the ModelProviderModel builders.
+	ModelProviderModel *ModelProviderModelClient
 	// Setting is the client for interacting with the Setting builders.
 	Setting *SettingClient
 	// Task is the client for interacting with the Task builders.
@@ -184,6 +188,8 @@ func (tx *Tx) init() {
 	tx.BillingUsage = NewBillingUsageClient(tx.config)
 	tx.InviteCode = NewInviteCodeClient(tx.config)
 	tx.Model = NewModelClient(tx.config)
+	tx.ModelProvider = NewModelProviderClient(tx.config)
+	tx.ModelProviderModel = NewModelProviderModelClient(tx.config)
 	tx.Setting = NewSettingClient(tx.config)
 	tx.Task = NewTaskClient(tx.config)
 	tx.TaskRecord = NewTaskRecordClient(tx.config)

backend/domain/billing.go

@@ -98,7 +98,9 @@ func (c *CompletionInfo) From(e *db.Task) *CompletionInfo {
 	}
 	c.ID = e.TaskID
 	c.Prompt = e.Prompt
-	c.Content = e.Completion
+	if len(e.Edges.TaskRecords) > 0 {
+		c.Content = e.Edges.TaskRecords[0].Completion
+	}
 	c.CreatedAt = e.CreatedAt.Unix()
 	return c
 }

backend/domain/model.go

@@ -19,8 +19,9 @@ type ModelUsecase interface {
 }
 
 type ModelRepo interface {
+	List(ctx context.Context) (*AllModelResp, error)
 	Create(ctx context.Context, m *CreateModelReq) (*db.Model, error)
-	Update(ctx context.Context, id string, fn func(up *db.ModelUpdateOne)) (*db.Model, error)
+	Update(ctx context.Context, id string, fn func(tx *db.Tx, old *db.Model, up *db.ModelUpdateOne) error) (*db.Model, error)
 	MyModelList(ctx context.Context, req *MyModelListReq) ([]*db.Model, error)
 	ModelUsage(ctx context.Context, ids []uuid.UUID) (map[uuid.UUID]ModelUsage, error)
 	GetTokenUsage(ctx context.Context, modelType consts.ModelType) (*ModelTokenUsageResp, error)

backend/ent/schema/modelprovider.go

@@ -0,0 +1,43 @@
+package schema
+
+import (
+	"time"
+
+	"entgo.io/ent"
+	"entgo.io/ent/dialect/entsql"
+	"entgo.io/ent/schema"
+	"entgo.io/ent/schema/edge"
+	"entgo.io/ent/schema/field"
+)
+
+// ModelProvider holds the schema definition for the ModelProvider entity.
+type ModelProvider struct {
+	ent.Schema
+}
+
+func (ModelProvider) Annotations() []schema.Annotation {
+	return []schema.Annotation{
+		entsql.Annotation{
+			Table: "model_providers",
+		},
+	}
+}
+
+// Fields of the ModelProvider.
+func (ModelProvider) Fields() []ent.Field {
+	return []ent.Field{
+		field.String("id").NotEmpty().Unique(),
+		field.String("name").NotEmpty(),
+		field.String("api_base").NotEmpty(),
+		field.Int("priority").Default(0),
+		field.Time("created_at").Default(time.Now),
+		field.Time("updated_at").Default(time.Now).UpdateDefault(time.Now),
+	}
+}
+
+// Edges of the ModelProvider.
+func (ModelProvider) Edges() []ent.Edge {
+	return []ent.Edge{
+		edge.To("models", ModelProviderModel.Type),
+	}
+}

backend/ent/schema/modelprovidermodel.go

@@ -0,0 +1,43 @@
+package schema
+
+import (
+	"time"
+
+	"entgo.io/ent"
+	"entgo.io/ent/dialect/entsql"
+	"entgo.io/ent/schema"
+	"entgo.io/ent/schema/edge"
+	"entgo.io/ent/schema/field"
+	"github.com/google/uuid"
+)
+
+// ModelProviderModel holds the schema definition for the ModelProviderModel entity.
+type ModelProviderModel struct {
+	ent.Schema
+}
+
+func (ModelProviderModel) Annotations() []schema.Annotation {
+	return []schema.Annotation{
+		entsql.Annotation{
+			Table: "model_provider_models",
+		},
+	}
+}
+
+// Fields of the ModelProviderModel.
+func (ModelProviderModel) Fields() []ent.Field {
+	return []ent.Field{
+		field.UUID("id", uuid.UUID{}).Default(uuid.New),
+		field.String("name").NotEmpty(),
+		field.String("provider_id").Optional(),
+		field.Time("created_at").Default(time.Now),
+		field.Time("updated_at").Default(time.Now).UpdateDefault(time.Now),
+	}
+}
+
+// Edges of the ModelProviderModel.
+func (ModelProviderModel) Edges() []ent.Edge {
+	return []ent.Edge{
+		edge.From("provider", ModelProvider.Type).Ref("models").Unique().Field("provider_id"),
+	}
+}

backend/internal/billing/handler/http/v1/billing.go

@@ -2,6 +2,7 @@ package v1
 
 import (
 	"github.com/GoYoko/web"
+
 	"github.com/chaitin/MonkeyCode/backend/domain"
 	"github.com/chaitin/MonkeyCode/backend/internal/middleware"
 )

backend/internal/billing/repo/billing.go

@@ -40,7 +40,12 @@ func (b *BillingRepo) ChatInfo(ctx context.Context, id string) (*domain.ChatInfo
 
 // CompletionInfo implements domain.BillingRepo.
 func (b *BillingRepo) CompletionInfo(ctx context.Context, id string) (*domain.CompletionInfo, error) {
-	record, err := b.db.Task.Query().Where(task.TaskID(id)).First(ctx)
+	record, err := b.db.Task.Query().
+		WithTaskRecords(func(trq *db.TaskRecordQuery) {
+			trq.Order(taskrecord.ByCreatedAt(sql.OrderAsc()))
+		}).
+		Where(task.TaskID(id)).
+		First(ctx)
 	if err != nil {
 		return nil, err
 	}

backend/internal/model/repo/model.go

@@ -4,7 +4,7 @@ import (
 	"context"
 	"time"
 
-	entsql "entgo.io/ent/dialect/sql"
+	"entgo.io/ent/dialect/sql"
 	"github.com/google/uuid"
 
 	"github.com/chaitin/MonkeyCode/backend/consts"
@@ -36,11 +36,11 @@ func (r *ModelRepo) Create(ctx context.Context, m *domain.CreateModelReq) (*db.M
 		SetAPIBase(m.APIBase).
 		SetAPIKey(m.APIKey).
 		SetModelType(m.ModelType).
-		SetStatus(consts.ModelStatusActive).
+		SetStatus(consts.ModelStatusInactive).
 		Save(ctx)
 }
 
-func (r *ModelRepo) Update(ctx context.Context, id string, fn func(up *db.ModelUpdateOne)) (*db.Model, error) {
+func (r *ModelRepo) Update(ctx context.Context, id string, fn func(tx *db.Tx, old *db.Model, up *db.ModelUpdateOne) error) (*db.Model, error) {
 	modelID, err := uuid.Parse(id)
 	if err != nil {
 		return nil, err
@@ -53,7 +53,9 @@ func (r *ModelRepo) Update(ctx context.Context, id string, fn func(up *db.ModelU
 		}
 
 		up := tx.Model.UpdateOneID(old.ID)
-		fn(up)
+		if err := fn(tx, old, up); err != nil {
+			return err
+		}
 		if n, err := up.Save(ctx); err != nil {
 			return err
 		} else {
@@ -69,7 +71,10 @@ func (r *ModelRepo) MyModelList(ctx context.Context, req *domain.MyModelListReq)
 	if err != nil {
 		return nil, err
 	}
-	q := r.db.Model.Query().Where(model.UserID(userID)).Where(model.ModelType(req.ModelType))
+	q := r.db.Model.Query().
+		Where(model.UserID(userID)).
+		Where(model.ModelType(req.ModelType)).
+		Order(model.ByCreatedAt(sql.OrderAsc()))
 	return q.All(ctx)
 }
 
@@ -77,11 +82,11 @@ func (r *ModelRepo) ModelUsage(ctx context.Context, ids []uuid.UUID) (map[uuid.U
 	var usages []domain.ModelUsage
 	err := r.db.Task.Query().
 		Where(task.ModelIDIn(ids...)).
-		Modify(func(s *entsql.Selector) {
+		Modify(func(s *sql.Selector) {
 			s.Select(
-				entsql.As(task.FieldModelID, "model_id"),
-				entsql.As(entsql.Sum(task.FieldInputTokens), "input"),
-				entsql.As(entsql.Sum(task.FieldOutputTokens), "output"),
+				sql.As(task.FieldModelID, "model_id"),
+				sql.As(sql.Sum(task.FieldInputTokens), "input"),
+				sql.As(sql.Sum(task.FieldOutputTokens), "output"),
 			).
 				GroupBy("model_id").
 				OrderBy("model_id")
@@ -114,11 +119,11 @@ func (r *ModelRepo) GetTokenUsage(ctx context.Context, modelType consts.ModelTyp
 			task.ModelType(modelType),
 			task.CreatedAtGTE(time.Now().AddDate(0, 0, -90)),
 		).
-		Modify(func(s *entsql.Selector) {
+		Modify(func(s *sql.Selector) {
 			s.Select(
-				entsql.As("date_trunc('day', created_at)", "date"),
-				entsql.As(entsql.Sum(task.FieldInputTokens), "input_tokens"),
-				entsql.As(entsql.Sum(task.FieldOutputTokens), "output_tokens"),
+				sql.As("date_trunc('day', created_at)", "date"),
+				sql.As(sql.Sum(task.FieldInputTokens), "input_tokens"),
+				sql.As(sql.Sum(task.FieldOutputTokens), "output_tokens"),
 			).
 				GroupBy("date").
 				OrderBy("date")
@@ -149,3 +154,26 @@ func (r *ModelRepo) GetTokenUsage(ctx context.Context, modelType consts.ModelTyp
 
 	return resp, nil
 }
+
+func (r *ModelRepo) List(ctx context.Context) (*domain.AllModelResp, error) {
+	providers, err := r.db.ModelProvider.Query().WithModels().All(ctx)
+	if err != nil {
+		return nil, err
+	}
+
+	resp := &domain.AllModelResp{
+		Providers: cvt.Iter(providers, func(_ int, p *db.ModelProvider) domain.ProviderModel {
+			return domain.ProviderModel{
+				Provider: p.Name,
+				Models: cvt.Iter(p.Edges.Models, func(_ int, m *db.ModelProviderModel) domain.ModelBasic {
+					return domain.ModelBasic{
+						Name:     m.Name,
+						Provider: p.Name,
+						APIBase:  p.APIBase,
+					}
+				}),
+			}
+		}),
+	}
+	return resp, nil
+}

backend/internal/model/usecase/model.go

@@ -5,6 +5,7 @@ import (
 
 	"github.com/google/uuid"
 
+	"github.com/chaitin/MonkeyCode/backend/db/model"
 	"github.com/chaitin/MonkeyCode/backend/pkg/cvt"
 
 	"github.com/chaitin/MonkeyCode/backend/consts"
@@ -47,50 +48,7 @@ func (m *ModelUsecase) MyModelList(ctx context.Context, req *domain.MyModelListR
 }
 
 func (m *ModelUsecase) List(ctx context.Context) (*domain.AllModelResp, error) {
-	return &domain.AllModelResp{
-		Providers: []domain.ProviderModel{
-			{
-				Provider: "百智云",
-				Models: []domain.ModelBasic{
-					{
-						Provider: "百智云",
-						Name:     "deepseek-v3",
-						APIBase:  "https://model-square.app.baizhi.cloud/v1",
-					},
-					{
-						Provider: "百智云",
-						Name:     "deepseek-r1",
-						APIBase:  "https://model-square.app.baizhi.cloud/v1",
-					},
-					{
-						Provider: "百智云",
-						Name:     "qwen2.5-coder-1.5b-instruct",
-						APIBase:  "https://model-square.app.baizhi.cloud/v1",
-					},
-					{
-						Provider: "百智云",
-						Name:     "qwen2.5-coder-7b-instruct",
-						APIBase:  "https://model-square.app.baizhi.cloud/v1",
-					},
-				},
-			},
-			{
-				Provider: "DeepSeek",
-				Models: []domain.ModelBasic{
-					{
-						Provider: "DeepSeek",
-						Name:     "deepseek-chat",
-						APIBase:  "https://api.deepseek.com",
-					},
-					{
-						Provider: "DeepSeek",
-						Name:     "deepseek-reasoner",
-						APIBase:  "https://api.deepseek.com",
-					},
-				},
-			},
-		},
-	}, nil
+	return m.repo.List(ctx)
 }
 
 // Create implements domain.ModelUsecase.
@@ -109,7 +67,7 @@ func (m *ModelUsecase) GetTokenUsage(ctx context.Context, modelType consts.Model
 
 // Update implements domain.ModelUsecase.
 func (m *ModelUsecase) Update(ctx context.Context, req *domain.UpdateModelReq) (*domain.Model, error) {
-	model, err := m.repo.Update(ctx, req.ID, func(up *db.ModelUpdateOne) {
+	model, err := m.repo.Update(ctx, req.ID, func(tx *db.Tx, old *db.Model, up *db.ModelUpdateOne) error {
 		if req.ModelName != nil {
 			up.SetModelName(*req.ModelName)
 		}
@@ -123,8 +81,17 @@ func (m *ModelUsecase) Update(ctx context.Context, req *domain.UpdateModelReq) (
 			up.SetAPIKey(*req.APIKey)
 		}
 		if req.Status != nil {
+			if *req.Status == consts.ModelStatusActive {
+				if err := tx.Model.Update().
+					Where(model.ModelType(old.ModelType)).
+					SetStatus(consts.ModelStatusInactive).
+					Exec(ctx); err != nil {
+					return err
+				}
+			}
 			up.SetStatus(*req.Status)
 		}
+		return nil
 	})
 	if err != nil {
 		return nil, err

backend/migration/000003_create_model_provider.up.sql

@@ -0,0 +1,33 @@
+CREATE TABLE IF NOT EXISTS model_providers (
+    id VARCHAR(255) PRIMARY KEY,
+    name VARCHAR(255) NOT NULL,
+    api_base VARCHAR(2048) NOT NULL,
+    priority INT NOT NULL DEFAULT 0,
+    created_at TIMESTAMPTZ DEFAULT CURRENT_TIMESTAMP,
+    updated_at TIMESTAMPTZ DEFAULT CURRENT_TIMESTAMP
+);
+
+CREATE UNIQUE INDEX IF NOT EXISTS unique_idx_model_providers_name ON model_providers (name);
+
+CREATE TABLE IF NOT EXISTS model_provider_models (
+    id UUID PRIMARY KEY DEFAULT uuid_generate_v1(),
+    provider_id VARCHAR(255) NOT NULL,
+    name VARCHAR(255) NOT NULL,
+    created_at TIMESTAMPTZ DEFAULT CURRENT_TIMESTAMP,
+    updated_at TIMESTAMPTZ DEFAULT CURRENT_TIMESTAMP
+);
+
+CREATE UNIQUE INDEX IF NOT EXISTS unique_idx_model_provider_models_provider_id_name ON model_provider_models (provider_id, name);
+
+INSERT INTO model_providers (id, name, api_base, priority) VALUES
+('baizhiyun', '百智云', 'https://model-square.app.baizhi.cloud/v1', 100),
+('deepseek', 'DeepSeek', 'https://api.deepseek.com', 90);
+
+INSERT INTO model_provider_models (provider_id, name) VALUES
+('baizhiyun', 'deepseek-v3'),
+('baizhiyun', 'deepseek-r1'),
+('baizhiyun', 'qwen2.5-coder-1.5b-instruct'),
+('baizhiyun', 'qwen2.5-coder-3b-instruct'),
+('baizhiyun', 'qwen2.5-coder-7b-instruct'),
+('deepseek', 'deepseek-chat'),
+('deepseek', 'deepseek-reasoner');