Skip to content

RAGFlow is an agent-native database: a Retrieval-Augmented Generation (RAG) engine that grew into context infrastructure.

refa: migrate model resolution to ModelSolver (#19820)

buua4363fc84c6a25cc
diff --git a/cmd/ragflow_server.go b/cmd/ragflow_server.go
index 07bb31442b..94e4439b6a 100644
--- a/cmd/ragflow_server.go
+++ b/cmd/ragflow_server.go
@@ -1108,6 +1108,7 @@ func startServer(ctx context.Context, args *serverArgs) error {
memoryService := service.NewMemoryService()
mcpService := service.NewMCPService()
modelProviderService := service.NewModelProviderService()
+ modelSolver := service.NewModelSolver()
// Wire the real MemorySaver so the Message component can persist
// conversation turns to memory stores declared in the canvas DSL.
@@ -1117,12 +1118,26 @@ func startServer(ctx context.Context, args *serverArgs) error {
docEngine := engine.Get()
documentDAO := dao.NewDocumentDAO()
retrievalEnhancer := retrievalbridge.NewEnhancer(docEngine, metadataService)
- agenttool.SetRetrievalService(agenttool.NewNLPRetrievalAdapterFromDeps(
+ retrievalAdapter := agenttool.NewNLPRetrievalAdapterFromDeps(
docEngine,
documentDAO,
- modelProviderService,
+ nil,
retrievalEnhancer,
- ))
+ )
+ retrievalAdapter.SetModelConfigResolver(func(ctx context.Context, tenantID string, modelType entity.ModelType, modelRef string) (modelModule.ModelDriver, string, *modelModule.APIConfig, int, error) {
+ var target *service.ModelTarget
+ var err error
+ if strings.TrimSpace(modelRef) == "" {
+ target, err = modelSolver.ResolveDefaultModelConfig(ctx, tenantID, modelType)
+ } else {
+ target, err = modelSolver.ResolveModelConfig(ctx, tenantID, modelType, modelRef)
+ }
+ if err != nil {
+ return nil, "", nil, 0, err
+ }
+ return target.Driver, target.ModelName, target.APIConfig, target.MaxTokens, nil
+ })
+ agenttool.SetRetrievalService(retrievalAdapter)
agenttool.SetMemoryRetrievalService(retrievalbridge.NewMemoryAdapter(memoryService))
common.Info("agent: retrieval service adapter installed")
@@ -1150,16 +1165,16 @@ func startServer(ctx context.Context, args *serverArgs) error {
// key's model component; empty disables that cache.
resolvedModelName := ""
if req.ModelID != "" {
- if driver, modelName, apiCfg, contentLen, mErr := modelProviderService.ResolveModelConfig(ctx, req.TenantID, entity.ModelTypeChat, req.ModelID); mErr == nil {
- if inv := component.NewResolvedInvoker(driver, modelName, apiCfg); inv != nil {
+ if target, mErr := modelSolver.ResolveModelConfig(ctx, req.TenantID, entity.ModelTypeChat, req.ModelID); mErr == nil {
+ if inv := component.NewResolvedInvoker(target.Driver, target.ModelName, target.APIConfig); inv != nil {
// MaxLength mirrors Python LLMBundle.max_length (the model's
// context window in tokens); message-fitting nodes (calculate,
// structure_qa) use it as their chat.FitMessages budget.
- model = &agenticruntime.InvokerSessionModel{Invoker: inv, DB: dao.DB, MaxLength: contentLen}
- resolvedModelName = modelName
+ model = &agenticruntime.InvokerSessionModel{Invoker: inv, DB: dao.DB, MaxLength: target.ContextLength}
+ resolvedModelName = target.ModelName
// Reuse the same resolved driver/name/api as the invoker so
// the outer loop and the inner tool calls share one model.
- outerModel = modelModule.NewChatModel(driver, &modelName, apiCfg)
+ outerModel = modelModule.NewChatModel(target.Driver, &target.ModelName, target.APIConfig)
}
} else {
common.Warn("runtime: failed to resolve chat model for reasoning; runtime will degrade to direct search", zap.Error(mErr))
diff --git a/internal/agent/tool/retrieval_nlp.go b/internal/agent/tool/retrieval_nlp.go
index 8d628f0508..334cac4e81 100644
--- a/internal/agent/tool/retrieval_nlp.go
+++ b/internal/agent/tool/retrieval_nlp.go
@@ -86,40 +86,24 @@ var retrievalUserPrefixPattern = regexp.MustCompile(`(?i)^user[::\s]*`)
// beyond its docEngine + documentDAO handles, both of which the
// nlp package treats as concurrent-safe.
type NLPRetrievalAdapter struct {
- svc *nlp.RetrievalService
- kbDAO knowledgebaseLookup
- modelResolver modelResolver
- enhancer retrievalEnhancer
+ svc *nlp.RetrievalService
+ kbDAO knowledgebaseLookup
+ modelConfigResolver modelConfigResolver
+ enhancer retrievalEnhancer
}
+type modelConfigResolver func(
+ ctx context.Context,
+ tenantID string,
+ modelType entity.ModelType,
+ modelRef string,
+) (modelModule.ModelDriver, string, *modelModule.APIConfig, int, error)
+
type knowledgebaseLookup interface {
GetByIDs(ctx context.Context, sqlDB *gorm.DB, ids []string) ([]*entity.Knowledgebase, error)
GetByName(ctx context.Context, sqlDB *gorm.DB, name, tenantID string) (*entity.Knowledgebase, error)
}
-// modelResolver is the narrow model-provider surface needed by retrieval.
-// Keeping this interface in the tool package avoids importing the parent
-// internal/service package, which already depends on agent/tool.
-type modelResolver interface {
- GetModelConfigByID(
- ctx context.Context,
- tenantID string,
- modelType entity.ModelType,
- modelID string,
- ) (modelModule.ModelDriver, string, *modelModule.APIConfig, int, error)
- ResolveModelConfig(
- ctx context.Context,
- tenantID string,
- modelType entity.ModelType,
- modelRef string,
- ) (modelModule.ModelDriver, string, *modelModule.APIConfig, int, error)
- GetTenantDefaultModelByType(
- ctx context.Context,
- tenantID string,
- modelType entity.ModelType,
- ) (modelModule.ModelDriver, string, *modelModule.APIConfig, int, error)
-}
-
// retrievalEnhancer exposes the service-layer query and result enhancements
// without making agent/tool import the parent internal/service package.
type retrievalEnhancer interface {
@@ -160,14 +144,14 @@ type retrievalEnhancer interface {
// *nlp.RetrievalService.
func NewNLPRetrievalAdapter(
svc *nlp.RetrievalService,
- resolver modelResolver,
+ resolver modelConfigResolver,
enhancer retrievalEnhancer,
) *NLPRetrievalAdapter {
return &NLPRetrievalAdapter{
- svc: svc,
- kbDAO: dao.NewKnowledgebaseDAO(),
- modelResolver: resolver,
- enhancer: enhancer,
+ svc: svc,
+ kbDAO: dao.NewKnowledgebaseDAO(),
+ modelConfigResolver: resolver,
+ enhancer: enhancer,
}
}
@@ -179,15 +163,35 @@ func NewNLPRetrievalAdapter(
func NewNLPRetrievalAdapterFromDeps(
docEngine engine.DocEngine,
documentDAO *dao.DocumentDAO,
- resolver modelResolver,
+ resolver modelConfigResolver,
enhancer retrievalEnhancer,
) *NLPRetrievalAdapter {
return &NLPRetrievalAdapter{
- svc: nlp.NewRetrievalService(docEngine, documentDAO),
- kbDAO: dao.NewKnowledgebaseDAO(),
- modelResolver: resolver,
- enhancer: enhancer,
+ svc: nlp.NewRetrievalService(docEngine, documentDAO),
+ kbDAO: dao.NewKnowledgebaseDAO(),
+ modelConfigResolver: resolver,
+ enhancer: enhancer,
+ }
+}
+
+// SetModelConfigResolver installs modelRef-based resolution without coupling
+// the agent tool package to the parent service package.
+func (a *NLPRetrievalAdapter) SetModelConfigResolver(resolver modelConfigResolver) {
+ if a != nil {
+ a.modelConfigResolver = resolver
+ }
+}
+
+func (a *NLPRetrievalAdapter) resolveModelConfig(
+ ctx context.Context,
+ tenantID string,
+ modelType entity.ModelType,
+ modelRef string,
+) (modelModule.ModelDriver, string, *modelModule.APIConfig, int, error) {
+ if a == nil || a.modelConfigResolver == nil {
+ return nil, "", nil, 0, fmt.Errorf("retrieval: model config resolver is not configured")
}
+ return a.modelConfigResolver(ctx, tenantID, modelType, modelRef)
}
// Search implements RetrievalService. The translation rules live
@@ -480,7 +484,7 @@ func (a *NLPRetrievalAdapter) resolveEmbeddingModel(
ctx context.Context,
kb *entity.Knowledgebase,
) (*modelModule.EmbeddingModel, error) {
- if a == nil || a.modelResolver == nil {
+ if a == nil {
return nil, fmt.Errorf("retrieval: embedding model resolver is not configured")
}
@@ -493,16 +497,16 @@ func (a *NLPRetrievalAdapter) resolveEmbeddingModel(
)
switch {
case kb.TenantEmbdID != nil && strings.TrimSpace(*kb.TenantEmbdID) != "":
- driver, modelName, apiConfig, maxTokens, err = a.modelResolver.GetModelConfigByID(
+ driver, modelName, apiConfig, maxTokens, err = a.resolveModelConfig(
ctx, kb.TenantID, entity.ModelTypeEmbedding, *kb.TenantEmbdID,
)
case strings.TrimSpace(kb.EmbdID) != "":
- driver, modelName, apiConfig, maxTokens, err = a.modelResolver.ResolveModelConfig(
+ driver, modelName, apiConfig, maxTokens, err = a.resolveModelConfig(
ctx, kb.TenantID, entity.ModelTypeEmbedding, kb.EmbdID,
)
default:
- driver, modelName, apiConfig, maxTokens, err = a.modelResolver.GetTenantDefaultModelByType(
- ctx, kb.TenantID, entity.ModelTypeEmbedding,
+ driver, modelName, apiConfig, maxTokens, err = a.resolveModelConfig(
+ ctx, kb.TenantID, entity.ModelTypeEmbedding, "",
)
}
if err != nil {
@@ -521,11 +525,11 @@ func (a *NLPRetrievalAdapter) resolveChatModel(
if !needsChatModel {
return nil, nil
}
- if a == nil || a.modelResolver == nil {
+ if a == nil {
return nil, fmt.Errorf("retrieval: model resolver is not configured")
}
- driver, modelName, apiConfig, _, err := a.modelResolver.GetTenantDefaultModelByType(
- ctx, tenantID, entity.ModelTypeChat,
+ driver, modelName, apiConfig, _, err := a.resolveModelConfig(
+ ctx, tenantID, entity.ModelTypeChat, "",
)
if err != nil {
return nil, fmt.Errorf("retrieval: resolve default chat model: %w", err)
@@ -541,7 +545,7 @@ func (a *NLPRetrievalAdapter) resolveRerankModel(
if req.RerankID == "" {
return nil, nil
}
- if a == nil || a.modelResolver == nil {
+ if a == nil || a.modelConfigResolver == nil {
return nil, fmt.Errorf("retrieval: model resolver is not configured")
}
var (
@@ -551,7 +555,7 @@ func (a *NLPRetrievalAdapter) resolveRerankModel(
maxTokens int
err error
)
- driver, modelName, apiConfig, maxTokens, err = a.modelResolver.ResolveModelConfig(
+ driver, modelName, apiConfig, maxTokens, err = a.resolveModelConfig(
ctx, tenantID, entity.ModelTypeRerank, req.RerankID,
)
if err != nil {
diff --git a/internal/agent/tool/retrieval_nlp_test.go b/internal/agent/tool/retrieval_nlp_test.go
index e194c70759..eb2e92eb34 100644
--- a/internal/agent/tool/retrieval_nlp_test.go
+++ b/internal/agent/tool/retrieval_nlp_test.go
@@ -430,7 +430,7 @@ func TestNLPRetrievalAdapter_ResolveEmbeddingModelPriority(t *testing.T) {
EmbdID: "embedding@provider",
TenantEmbdID: &tenantEmbeddingID,
},
- wantCall: "id:tenant-embedding-1",
+ wantCall: "resolve:tenant-embedding-1",
},
{
name: "knowledge base embedding reference",
@@ -447,14 +447,24 @@ func TestNLPRetrievalAdapter_ResolveEmbeddingModelPriority(t *testing.T) {
ID: "kb-1",
TenantID: "tenant-1",
},
- wantCall: "default",
+ wantCall: "resolve:",
},
}
for _, test := range tests {
t.Run(test.name, func(t *testing.T) {
resolver := &fakeModelResolver{modelName: "resolved-model"}
- adapter := &NLPRetrievalAdapter{modelResolver: resolver}
+ adapter := &NLPRetrievalAdapter{
+ modelConfigResolver: func(
+ _ context.Context,
+ _ string,
+ _ entity.ModelType,
+ modelRef string,
+ ) (modelModule.ModelDriver, string, *modelModule.APIConfig, int, error) {
+ resolver.call = "resolve:" + modelRef
+ return nil, resolver.modelName, &modelModule.APIConfig{}, 512, resolver.err
+ },
+ }
model, err := adapter.resolveEmbeddingModel(t.Context(), test.kb)
if err != nil {
t.Fatalf("resolveEmbeddingModel: %v", err)
@@ -514,35 +524,6 @@ type fakeModelResolver struct {
err error
}
-func (f *fakeModelResolver) GetModelConfigByID(
- _ context.Context,
- _ string,
- _ entity.ModelType,
- modelID string,
-) (modelModule.ModelDriver, string, *modelModule.APIConfig, int, error) {
- f.call = "id:" + modelID
- return nil, f.modelName, &modelModule.APIConfig{}, 512, f.err
-}
-
-func (f *fakeModelResolver) ResolveModelConfig(
- _ context.Context,
- _ string,
- _ entity.ModelType,
- modelRef string,
-) (modelModule.ModelDriver, string, *modelModule.APIConfig, int, error) {
- f.call = "resolve:" + modelRef
- return nil, f.modelName, &modelModule.APIConfig{}, 512, f.err
-}
-
-func (f *fakeModelResolver) GetTenantDefaultModelByType(
- _ context.Context,
- _ string,
- _ entity.ModelType,
-) (modelModule.ModelDriver, string, *modelModule.APIConfig, int, error) {
- f.call = "default"
- return nil, f.modelName, &modelModule.APIConfig{}, 512, f.err
-}
-
func (f fakeKnowledgebaseLookup) GetByIDs(ctx context.Context, db *gorm.DB, ids []string) ([]*entity.Knowledgebase, error) {
requested := make(map[string]struct{}, len(ids))
for _, id := range ids {
diff --git a/internal/handler/chat_audio.go b/internal/handler/chat_audio.go
index e23c2433e5..9b39d25e16 100644
--- a/internal/handler/chat_audio.go
+++ b/internal/handler/chat_audio.go
@@ -32,6 +32,7 @@ import (
"ragflow/internal/common"
"ragflow/internal/entity"
modelModule "ragflow/internal/entity/models"
+ "ragflow/internal/service"
)
const (
@@ -73,11 +74,14 @@ func (h *ChatHandler) ChatAudioSpeech(c *gin.Context) {
return
}
- driver, modelName, apiConfig, _, err := h.llm.GetTenantDefaultModelByType(ctx, user.ID, entity.ModelTypeTTS)
+ target, err := service.NewModelSolver().ResolveDefaultModelConfig(ctx, user.ID, entity.ModelTypeTTS)
if err != nil {
common.ErrorWithCode(c, common.CodeDataError, err.Error())
return
}
+ driver := target.Driver
+ modelName := target.ModelName
+ apiConfig := target.APIConfig
writeAudioHeaders := func(mediaType string) {
c.Header("Content-Type", mediaType)
@@ -254,11 +258,14 @@ func (h *ChatHandler) ChatAudioTranscription(c *gin.Context) {
return
}
- driver, modelName, apiConfig, _, err := h.llm.GetTenantDefaultModelByType(ctx, user.ID, entity.ModelTypeSpeech2Text)
+ target, err := service.NewModelSolver().ResolveDefaultModelConfig(ctx, user.ID, entity.ModelTypeSpeech2Text)
if err != nil {
common.ErrorWithCode(c, common.CodeDataError, err.Error())
return
}
+ driver := target.Driver
+ modelName := target.ModelName
+ apiConfig := target.APIConfig
streamMode := strings.ToLower(c.PostForm("stream")) == "true"
if streamMode {
diff --git a/internal/ingestion/task/knowledge_compiler_wiring.go b/internal/ingestion/task/knowledge_compiler_wiring.go
index 92d682d08b..ec76467572 100644
--- a/internal/ingestion/task/knowledge_compiler_wiring.go
+++ b/internal/ingestion/task/knowledge_compiler_wiring.go
@@ -498,54 +498,50 @@ func newKnowledgeCompilerTemplateResolver() kc.TemplateResolver {
// component resolves its embedder.
func newKnowledgeCompilerDepsResolver() kc.DepsResolver {
svc := service.NewModelProviderService()
+ modelSolver := service.NewModelSolver()
return func(tenantID, llmID, embeddingModel string) (kc.Deps, error) {
if strings.TrimSpace(llmID) == "" {
// No explicit chat model was supplied (e.g. the dataset-level deduper
// is seeded with a global default that may be empty). Resolve the
// tenant's default chat model so cross-document LLM merging can
// actually run instead of failing / falling back to a no-op. Use the
- // composite "<model>@<instance>@<provider>" reference (not the bare
- // model name) so later Chat/ResolveModelConfig round-trips can locate
- // the provider.
- defaultRef, derr := svc.GetTenantDefaultModelRef(context.Background(), tenantID, entity.ModelTypeChat)
- if derr != nil || strings.TrimSpace(defaultRef) == "" {
+ // tenant model ID so later model resolution can use the same persisted
+ // tenant model directly.
+ defaultTarget, derr := modelSolver.ResolveDefaultModelConfig(context.Background(), tenantID, entity.ModelTypeChat)
+ if derr != nil || defaultTarget == nil || strings.TrimSpace(defaultTarget.ModelID) == "" {
return kc.Deps{}, fmt.Errorf("knowledge_compiler: llm_id is empty and no tenant default chat model available: %w", derr)
}
- llmID = defaultRef
+ llmID = defaultTarget.ModelID
// Keep the fall-through path below for ModelContextLen resolution so
// both explicit and default model refs share one context-window path.
}
// Resolve the chat model's context window so RAPTOR can truncate each
// cluster's texts to fit the LLM context (mirrors Python self._llm_model.max_length).
- // This uses content_length (PR #17839) — the total context window — not
- // max_output. max_output is only the generation cap; using it as the
- // budget source would collapse per-chunk input quotas.
+ // ContextLength is the total context window; MaxTokens is only the
+ // generation cap and must not be used as the input budget.
llmMax := kc.DefaultLLMContextLength
// Bound the model-config lookup so a stalled provider/instance DB read
// cannot block document ingestion indefinitely.
contextLengthCtx, cancelContextLength := context.WithTimeout(context.Background(), 30*time.Second)
- ml, contextLengthErr := svc.ResolveModelContextLength(contextLengthCtx, tenantID, llmID)
+ modelTarget, contextLengthErr := modelSolver.ResolveModelConfig(contextLengthCtx, tenantID, entity.ModelTypeChat, llmID)
cancelContextLength()
- if contextLengthErr == nil && ml > 0 {
- llmMax = ml
+ if contextLengthErr == nil && modelTarget != nil && modelTarget.ContextLength > 0 {
+ llmMax = modelTarget.ContextLength
}
// Resolve the model's generation cap (max_output). Cross-document merge
// judging packs many pairs into one LLM call; the batch must be bounded by
// BOTH the input window and this output cap, so a large candidate set
// never overflows max_output and yields a truncated/non-JSON reply. This
// uses max_tokens (the generation cap), NOT content_length — see
- // ResolveModelContextLength's comment.
+ // ModelSolver.ResolveModelConfig's ContextLength and MaxTokens fields.
llmMaxOutput := 0
- modelConfigCtx, cancelModelConfig := context.WithTimeout(context.Background(), 30*time.Second)
- _, _, _, mo, modelConfigErr := svc.ResolveModelConfig(modelConfigCtx, tenantID, entity.ModelTypeChat, llmID)
- cancelModelConfig()
- if modelConfigErr == nil && mo > 0 {
- llmMaxOutput = mo
+ if contextLengthErr == nil && modelTarget != nil && modelTarget.MaxTokens > 0 {
+ llmMaxOutput = modelTarget.MaxTokens
}
return kc.Deps{
Chat: &kcChatInvoker{svc: svc, tenantID: tenantID, llmID: llmID},
- Embed: &kcEmbedder{svc: svc, tenantID: tenantID, embdID: embeddingModel},
+ Embed: &kcEmbedder{svc: svc, solver: modelSolver, tenantID: tenantID, embdID: embeddingModel},
WikiPages: &kcWikiPageStore{docEngine: engine.Get()},
WikiMapVersions: knowledge_compile.NewWikiMapVersionStore(engine.Get()),
// HistoricalKNN / Redis are optional (wiki historical dedup,
@@ -667,6 +663,7 @@ const kcChatRetryDelay = 2 * time.Second
// the component's product schema.
type kcEmbedder struct {
svc *service.ModelProviderService
+ solver *service.ModelSolver
tenantID string
embdID string
dim atomic.Int64
@@ -754,14 +751,14 @@ func (e *kcEmbedder) resolveModel(ctx context.Context) (*models.EmbeddingModel,
}
return mdl, nil
}
- driver, name, apiConfig, _, err := e.svc.GetTenantDefaultModelByType(ctx, e.tenantID, entity.ModelTypeEmbedding)
+ target, err := e.solver.ResolveDefaultModelConfig(ctx, e.tenantID, entity.ModelTypeEmbedding)
if err != nil {
return nil, fmt.Errorf("knowledge_compiler: embedding_model is required and no tenant default embedding model is set: %w", err)
}
- if driver == nil || name == "" {
+ if target == nil || target.Driver == nil || target.ModelName == "" {
return nil, fmt.Errorf("knowledge_compiler: embedding_model is required (tenant default embedding model unavailable)")
}
- return &models.EmbeddingModel{ModelDriver: driver, ModelName: &name, APIConfig: apiConfig}, nil
+ return &models.EmbeddingModel{ModelDriver: target.Driver, ModelName: &target.ModelName, APIConfig: target.APIConfig}, nil
}
func (e *kcEmbedder) Dimensions() int { return int(e.dim.Load()) }
diff --git a/internal/service/agent.go b/internal/service/agent.go
index b704ae71c5..f691968c50 100644
--- a/internal/service/agent.go
+++ b/internal/service/agent.go
@@ -1873,7 +1873,7 @@ func validateAgentChatModels(ctx context.Context, userID string, dsl map[string]
if err != nil {
return nil
}
- resolver := NewModelProviderService()
+ modelSolver := NewModelSolver()
for _, node := range c.Components {
if !strings.EqualFold(node.Obj.ComponentName, "Agent") {
continue
@@ -1882,7 +1882,7 @@ func validateAgentChatModels(ctx context.Context, userID string, dsl map[string]
if !ok {
modelRef, _ = node.Obj.Params["llm_id"].(string)
}
- if _, _, _, _, err := resolver.ResolveModelConfig(ctx, userID, entity.ModelTypeChat, modelRef); err != nil {
+ if _, err := modelSolver.ResolveModelConfig(ctx, userID, entity.ModelTypeChat, modelRef); err != nil {
if errors.Is(err, errModelConfigUnavailable) || errors.Is(err, gorm.ErrRecordNotFound) {
return errors.New("The configured chat model is missing or unavailable. Please select a valid model.")
}
diff --git a/internal/service/chat.go b/internal/service/chat.go
index ee804e2e85..c565bfde4f 100644
--- a/internal/service/chat.go
+++ b/internal/service/chat.go
@@ -435,15 +435,12 @@ func resolveCreateLLMID(ctx context.Context, llmID, tenantID string, llmSetting
}
}
}
- modelProvider := NewModelProviderService()
- if _, _, _, _, err := modelProvider.ResolveModelConfig(ctx, tenantID, modelType, llmID); err != nil {
- return "", fmt.Errorf("`llm_id` %s doesn't exist", llmID)
- }
- tenantLLMID, err := modelProvider.ResolveModelID(ctx, tenantID, modelType, llmID)
+ modelSolver := NewModelSolver()
+ target, err := modelSolver.ResolveModelConfig(ctx, tenantID, modelType, llmID)
if err != nil {
- return "", err
+ return "", fmt.Errorf("`llm_id` %s doesn't exist", llmID)
}
- return tenantLLMID, nil
+ return target.ModelID, nil
}
func resolveCreateRerankID(ctx context.Context, rerankID, tenantID string) (string, error) {
@@ -454,15 +451,12 @@ func resolveCreateRerankID(ctx context.Context, rerankID, tenantID string) (stri
if _, ok := DefaultRerankModels[llmName]; ok {
return "", nil
}
- modelProvider := NewModelProviderService()
- if _, _, _, _, err := modelProvider.ResolveModelConfig(ctx, tenantID, entity.ModelTypeRerank, rerankID); err != nil {
- return "", fmt.Errorf("`rerank_id` %s doesn't exist", rerankID)
- }
- tenantRerankID, err := modelProvider.ResolveModelID(ctx, tenantID, entity.ModelTypeRerank, rerankID)
+ modelSolver := NewModelSolver()
+ target, err := modelSolver.ResolveModelConfig(ctx, tenantID, entity.ModelTypeRerank, rerankID)
if err != nil {
- return "", err
+ return "", fmt.Errorf("`rerank_id` %s doesn't exist", rerankID)
}
- return tenantRerankID, nil
+ return target.ModelID, nil
}
func applyCreatePromptDefaults(req map[string]interface{}) {
@@ -1095,15 +1089,12 @@ func (s *ChatService) resolveRESTLLMID(ctx context.Context, llmID, tenantID stri
}
}
}
- modelProvider := NewModelProviderService()
- if _, _, _, _, err := modelProvider.ResolveModelConfig(ctx, tenantID, modelType, llmID); err != nil {
- return "", fmt.Errorf("`llm_id` %s doesn't exist", llmID)
- }
- tenantLLMID, err := modelProvider.ResolveModelID(ctx, tenantID, modelType, llmID)
+ modelSolver := NewModelSolver()
+ target, err := modelSolver.ResolveModelConfig(ctx, tenantID, modelType, llmID)
if err != nil {
- return "", err
+ return "", fmt.Errorf("`llm_id` %s doesn't exist", llmID)
}
- return tenantLLMID, nil
+ return target.ModelID, nil
}
func (s *ChatService) resolveRESTRerankID(ctx context.Context, rerankID, tenantID string) (string, error) {
@@ -1114,15 +1105,12 @@ func (s *ChatService) resolveRESTRerankID(ctx context.Context, rerankID, tenantI
if _, ok := defaultRerankModels[baseName]; ok {
return "", nil
}
- modelProvider := NewModelProviderService()
- if _, _, _, _, err := modelProvider.ResolveModelConfig(ctx, tenantID, entity.ModelTypeRerank, rerankID); err != nil {
- return "", fmt.Errorf("`rerank_id` %s doesn't exist", rerankID)
- }
- tenantRerankID, err := modelProvider.ResolveModelID(ctx, tenantID, entity.ModelTypeRerank, rerankID)
+ modelSolver := NewModelSolver()
+ target, err := modelSolver.ResolveModelConfig(ctx, tenantID, entity.ModelTypeRerank, rerankID)
if err != nil {
- return "", err
+ return "", fmt.Errorf("`rerank_id` %s doesn't exist", rerankID)
}
- return tenantRerankID, nil
+ return target.ModelID, nil
}
func filterRESTChatUpdates(req map[string]interface{}) map[string]interface{} {
diff --git a/internal/service/chat_pipeline.go b/internal/service/chat_pipeline.go
index 37d42e5791..e9081447fe 100644
--- a/internal/service/chat_pipeline.go
+++ b/internal/service/chat_pipeline.go
@@ -1565,7 +1565,7 @@ func (s *ChatPipelineService) AsyncChatSolo(
}
// 4. Build the chat model wrapper.
- driver, modelName, apiConfig, _, err := s.ModelProviderSvc.GetChatModelConfig(ctx, chat.TenantID, chat.LLMID)
+ target, err := s.resolveChatModelTarget(ctx, chat)
if err != nil {
out <- AsyncChatResult{
Answer: fmt.Sprintf("**ERROR**: %s", err.Error()),
@@ -1573,21 +1573,19 @@ func (s *ChatPipelineService) AsyncChatSolo(
}
return
}
- chatModel := modelModule.NewChatModel(driver, &modelName, apiConfig)
+ chatModel := modelModule.NewChatModel(target.Driver, &target.ModelName, target.APIConfig)
// 5. Resolve TTS model. Best-effort: warn and proceed without TTS on lookup failure.
var ttsModel *modelModule.ChatModel
if promptConfig != nil {
if useTTS, _ := promptConfig["tts"].(bool); useTTS {
- ttsDriver, ttsName, ttsConfig, _, ttsErr := s.ModelProviderSvc.GetTenantDefaultModelByType(
- ctx, chat.TenantID, entity.ModelTypeTTS,
- )
- if ttsErr != nil {
+ target, ttsErr := s.ModelProviderSvc.modelSolver().ResolveDefaultModelConfig(ctx, chat.TenantID, entity.ModelTypeTTS)
+ if ttsErr != nil || target == nil {
common.Warn("AsyncChatSolo: TTS lookup failed; proceeding without TTS",
zap.String("tenant_id", chat.TenantID),
zap.Error(ttsErr))
} else {
- ttsModel = modelModule.NewChatModel(ttsDriver, &ttsName, ttsConfig)
+ ttsModel = modelModule.NewChatModel(target.Driver, &target.ModelName, target.APIConfig)
}
}
}
@@ -2076,8 +2074,12 @@ func tokenizeText(text string) string {
func (s *ChatPipelineService) getLLMModelConfig(ctx context.Context, chat *entity.Chat) (map[string]interface{}, string, string, string, error) {
if chat.LLMID == "" {
// Branch 3: no explicit LLM → tenant default chat model.
+ target, err := s.ModelProviderSvc.modelSolver().ResolveDefaultModelConfig(ctx, chat.TenantID, entity.ModelTypeChat)
+ if err != nil || target == nil {
+ return nil, "", "", "", err
+ }
cfg, modelName, factoryName, baseURL, err := s.buildLLMModelConfig(
- s.ModelProviderSvc.GetTenantDefaultModelByType(ctx, chat.TenantID, entity.ModelTypeChat),
+ target.Driver, target.ModelName, target.APIConfig, target.MaxTokens, err,
)
if err != nil {
return nil, "", "", "", err
@@ -2085,9 +2087,11 @@ func (s *ChatPipelineService) getLLMModelConfig(ctx context.Context, chat *entit
// Probe the default model's enrolled types so a vision-capable
// default dispatches as image2text (same rule as the explicit-LLM
// branches below).
- if ref, refErr := s.ModelProviderSvc.GetTenantDefaultModelRef(ctx, chat.TenantID, entity.ModelTypeChat); refErr == nil {
- cfg["model_type"] = s.resolveChatModelType(ctx, chat.TenantID, ref)
+ modelRef := target.ModelID
+ if modelRef == "" {
+ modelRef = fmt.Sprintf("%s@%s@%s", target.ModelName, target.InstanceName, target.ProviderName)
}
+ cfg["model_type"] = s.resolveChatModelType(ctx, chat.TenantID, modelRef)
return cfg, modelName, factoryName, baseURL, nil
}
@@ -2098,8 +2102,12 @@ func (s *ChatPipelineService) getLLMModelConfig(ctx context.Context, chat *entit
if modelTypeStr == "image2text" {
modelType = entity.ModelTypeImage2Text
}
+ target, err := s.ModelProviderSvc.modelSolver().ResolveModelConfig(ctx, chat.TenantID, modelType, chat.LLMID)
+ if err != nil {
+ return nil, "", "", "", err
+ }
cfg, modelName, factoryName, baseURL, err := s.buildLLMModelConfig(
- s.ModelProviderSvc.ResolveModelConfig(ctx, chat.TenantID, modelType, chat.LLMID),
+ target.Driver, target.ModelName, target.APIConfig, target.MaxTokens, nil,
)
if err != nil {
return nil, "", "", "", err
@@ -2108,13 +2116,25 @@ func (s *ChatPipelineService) getLLMModelConfig(ctx context.Context, chat *entit
return cfg, modelName, factoryName, baseURL, nil
}
+func (s *ChatPipelineService) resolveChatModelTarget(ctx context.Context, chat *entity.Chat) (*ModelTarget, error) {
+ if chat.LLMID == "" {
+ return s.ModelProviderSvc.modelSolver().ResolveDefaultModelConfig(ctx, chat.TenantID, entity.ModelTypeChat)
+ }
+
+ modelType := entity.ModelTypeChat
+ if s.resolveChatModelType(ctx, chat.TenantID, chat.LLMID) == "image2text" {
+ modelType = entity.ModelTypeImage2Text
+ }
+ return s.ModelProviderSvc.modelSolver().ResolveModelConfig(ctx, chat.TenantID, modelType, chat.LLMID)
+}
+
// resolveChatModelType probes the enrolled model types for llmRef and
// returns "image2text" when the model is vision-capable (enrolled with an
// image2text / "vision" type), "chat" otherwise. Probe failures are
// conservative: they yield "chat", which drops image attachments instead
// of risking a provider-side rejection.
func (s *ChatPipelineService) resolveChatModelType(ctx context.Context, tenantID, llmRef string) string {
- modelTypes, err := s.ModelProviderSvc.ResolveModelType(ctx, tenantID, llmRef)
+ modelTypes, err := s.ModelProviderSvc.modelSolver().ResolveModelType(ctx, tenantID, llmRef)
if err != nil {
return "chat"
}
@@ -2198,7 +2218,7 @@ func (s *ChatPipelineService) getModels(ctx context.Context, chat *entity.Chat)
}
if kbs[0].EmbdID != "" {
embdTenantID := kbs[0].TenantID
- driver, modelName, apiConfig, maxTokens, err := s.ModelProviderSvc.ResolveModelConfig(
+ target, err := s.ModelProviderSvc.modelSolver().ResolveModelConfig(
ctx, embdTenantID, entity.ModelTypeEmbedding, kbs[0].EmbdID,
)
if err != nil {
@@ -2208,25 +2228,25 @@ func (s *ChatPipelineService) getModels(ctx context.Context, chat *entity.Chat)
zap.Error(err))
return nil, nil, nil, nil, nil, fmt.Errorf("failed to get embedding model: %w", err)
}
- embModel = modelModule.NewEmbeddingModel(driver, &modelName, apiConfig, maxTokens)
+ embModel = modelModule.NewEmbeddingModel(target.Driver, &target.ModelName, target.APIConfig, target.MaxTokens)
}
}
// Chat model.
- driver, modelName, apiConfig, _, err := s.ModelProviderSvc.GetChatModelConfig(ctx, chat.TenantID, chat.LLMID)
+ target, err := s.resolveChatModelTarget(ctx, chat)
var chatModel *modelModule.ChatModel
if err == nil {
- chatModel = modelModule.NewChatModel(driver, &modelName, apiConfig)
+ chatModel = modelModule.NewChatModel(target.Driver, &target.ModelName, target.APIConfig)
}
// Rerank model.
var rerankModel *modelModule.RerankModel
if chat.RerankID != "" {
- rerankDriver, rerankName, rerankConfig, maxTokens, err := s.ModelProviderSvc.ResolveModelConfig(
+ target, err := s.ModelProviderSvc.modelSolver().ResolveModelConfig(
ctx, chat.TenantID, entity.ModelTypeRerank, chat.RerankID,
)
if err == nil {
- rerankModel = modelModule.NewRerankModel(rerankDriver, &rerankName, rerankConfig, maxTokens)
+ rerankModel = modelModule.NewRerankModel(target.Driver, &target.ModelName, target.APIConfig, target.MaxTokens)
}
}
@@ -2234,11 +2254,9 @@ func (s *ChatPipelineService) getModels(ctx context.Context, chat *entity.Chat)
var ttsModel *modelModule.ChatModel
if chat.PromptConfig != nil {
if useTTS, _ := chat.PromptConfig["tts"].(bool); useTTS {
- ttsDriver, ttsName, ttsConfig, _, err := s.ModelProviderSvc.GetTenantDefaultModelByType(
- ctx, chat.TenantID, entity.ModelTypeTTS,
- )
+ target, err := s.ModelProviderSvc.modelSolver().ResolveDefaultModelConfig(ctx, chat.TenantID, entity.ModelTypeTTS)
if err == nil {
- ttsModel = modelModule.NewChatModel(ttsDriver, &ttsName, ttsConfig)
+ ttsModel = modelModule.NewChatModel(target.Driver, &target.ModelName, target.APIConfig)
}
}
}
@@ -2789,11 +2807,11 @@ func (s *ChatPipelineService) buildChatDriver(ctx context.Context, chat *entity.
if chatModel != nil {
return chatModel
}
- driver, modelName, apiConfig, _, err := s.ModelProviderSvc.GetChatModelConfig(ctx, chat.TenantID, chat.LLMID)
+ target, err := s.resolveChatModelTarget(ctx, chat)
if err != nil {
return nil
}
- return modelModule.NewChatModel(driver, &modelName, apiConfig)
+ return modelModule.NewChatModel(target.Driver, &target.ModelName, target.APIConfig)
}
// HydrateChunkVectors fills the `vector` field on each chunk in `kbinfos`
diff --git a/internal/service/chat_pipeline_vision_test.go b/internal/service/chat_pipeline_vision_test.go
index c7bcb8d5e6..5064b86580 100644
--- a/internal/service/chat_pipeline_vision_test.go
+++ b/internal/service/chat_pipeline_vision_test.go
@@ -14,7 +14,7 @@ import (
// a ZHIPU-AI provider, a default instance, and enrolled models:
//
// glm-4-flash — chat only (text-only: rejects image content with error 1210)
-// glm-4v — chat + image2text, one tenant_model row per type
+// glm-4v — chat + image2text in one tenant_model row
// glm-4.6v-Flash — combined chat|image2text bitmask in a single row
//
// Enrollment rows are what getLLMModelConfig probes to decide whether image
@@ -46,8 +46,7 @@ func setupChatPipelineVisionTestDB(t *testing.T) *gorm.DB {
&entity.TenantModelProvider{ID: "provider-zhipu", TenantID: "tenant-1", ProviderName: "ZHIPU-AI"},
&entity.TenantModelInstance{ID: "instance-zhipu", ProviderID: "provider-zhipu", InstanceName: "default", APIKey: "sk-test", Status: "active", Extra: "{}"},
&entity.TenantModel{ID: "model-flash-chat", ProviderID: "provider-zhipu", InstanceID: "instance-zhipu", ModelName: "glm-4-flash", ModelType: int(entity.ModelTypeChat), Status: "active"},
- &entity.TenantModel{ID: "model-4v-chat", ProviderID: "provider-zhipu", InstanceID: "instance-zhipu", ModelName: "glm-4v", ModelType: int(entity.ModelTypeChat), Status: "active"},
- &entity.TenantModel{ID: "model-4v-i2t", ProviderID: "provider-zhipu", InstanceID: "instance-zhipu", ModelName: "glm-4v", ModelType: int(entity.ModelTypeImage2Text), Status: "active"},
+ &entity.TenantModel{ID: "model-4v", ProviderID: "provider-zhipu", InstanceID: "instance-zhipu", ModelName: "glm-4v", ModelType: int(entity.ModelTypeChat | entity.ModelTypeImage2Text), Status: "active"},
// Combined chat+image2text enrollment (bitmask), as produced for
// catalog entries with model_types ["chat", "vision"] (e.g. glm-4.6v-Flash).
&entity.TenantModel{ID: "model-46v-combined", ProviderID: "provider-zhipu", InstanceID: "instance-zhipu", ModelName: "glm-4.6v-Flash", ModelType: int(entity.ModelTypeChat | entity.ModelTypeImage2Text), Status: "active"},
diff --git a/internal/service/chat_session.go b/internal/service/chat_session.go
index 7486f2cf81..2cc3c8f2ef 100644
--- a/internal/service/chat_session.go
+++ b/internal/service/chat_session.go
@@ -25,7 +25,6 @@ import (
"math"
"ragflow/internal/common"
"ragflow/internal/engine"
- modelModule "ragflow/internal/entity/models"
"ragflow/internal/storage"
"ragflow/internal/utility"
"strconv"
@@ -61,7 +60,9 @@ type chatPipelineRunner interface {
}
type chatModelConfigResolver interface {
- GetChatModelConfig(ctx context.Context, tenantID, llmID string) (modelModule.ModelDriver, string, *modelModule.APIConfig, int, error)
+ ResolveModelConfig(ctx context.Context, tenantID string, modelType entity.ModelType, modelRef string) (*ModelTarget, error)
+ ResolveDefaultModelConfig(ctx context.Context, tenantID string, modelType entity.ModelType) (*ModelTarget, error)
+ ResolveModelType(ctx context.Context, tenantID, modelRef string) ([]entity.ModelType, error)
}
// chunkFeedbackApplier is the dispatch seam for chunk-level feedback
@@ -97,7 +98,7 @@ func NewChatSessionService() *ChatSessionService {
chatSessionDAO: dao.NewChatSessionDAO(),
userTenantDAO: dao.NewUserTenantDAO(),
pipeline: NewChatPipelineService(),
- modelProviderSvc: NewModelProviderService(),
+ modelProviderSvc: NewModelSolver(),
docEngine: engine.Get(),
}
}
@@ -1927,9 +1928,23 @@ func (s *ChatSessionService) initializeReference(session *entity.ChatSession) []
func (s *ChatSessionService) checkTenantLLMAPIKey(ctx context.Context, tenantID, modelName string) (bool, error) {
resolver := s.modelProviderSvc
if resolver == nil {
- resolver = NewModelProviderService()
+ resolver = NewModelSolver()
+ }
+ var err error
+ if modelName == "" {
+ _, err = resolver.ResolveDefaultModelConfig(ctx, tenantID, entity.ModelTypeChat)
+ } else {
+ modelType := entity.ModelTypeChat
+ if modelTypes, typeErr := resolver.ResolveModelType(ctx, tenantID, modelName); typeErr == nil {
+ for _, resolvedType := range modelTypes {
+ if resolvedType.Has(entity.ModelTypeImage2Text) {
+ modelType = entity.ModelTypeImage2Text
+ break
+ }
+ }
+ }
+ _, err = resolver.ResolveModelConfig(ctx, tenantID, modelType, modelName)
}
- _, _, _, _, err := resolver.GetChatModelConfig(ctx, tenantID, modelName)
if err != nil {
return false, err
}
diff --git a/internal/service/chat_session_test.go b/internal/service/chat_session_test.go
index 70f41207d1..68873139a4 100644
--- a/internal/service/chat_session_test.go
+++ b/internal/service/chat_session_test.go
@@ -243,13 +243,25 @@ type fakeChatModelConfigResolver struct {
err error
}
-func (f *fakeChatModelConfigResolver) GetChatModelConfig(ctx context.Context, tenantID, llmID string) (modelModule.ModelDriver, string, *modelModule.APIConfig, int, error) {
+func (f *fakeChatModelConfigResolver) ResolveModelConfig(ctx context.Context, tenantID string, modelType entity.ModelType, modelRef string) (*ModelTarget, error) {
f.tenantID = tenantID
- f.llmID = llmID
+ f.llmID = modelRef
if f.err != nil {
- return nil, "", nil, 0, f.err
+ return nil, f.err
}
- return nil, "resolved-model", &modelModule.APIConfig{}, 8192, nil
+ return &ModelTarget{ModelName: "resolved-model", APIConfig: &modelModule.APIConfig{}, MaxTokens: 8192}, nil
+}
+
+func (f *fakeChatModelConfigResolver) ResolveDefaultModelConfig(ctx context.Context, tenantID string, modelType entity.ModelType) (*ModelTarget, error) {
+ f.tenantID = tenantID
+ if f.err != nil {
+ return nil, f.err
+ }
+ return &ModelTarget{ModelName: "resolved-model", APIConfig: &modelModule.APIConfig{}, MaxTokens: 8192}, nil
+}
+
+func (f *fakeChatModelConfigResolver) ResolveModelType(ctx context.Context, tenantID, modelRef string) ([]entity.ModelType, error) {
+ return []entity.ModelType{entity.ModelTypeChat}, nil
}
type feedbackContextKey struct{}
diff --git a/internal/service/chunk/chunk.go b/internal/service/chunk/chunk.go
index f9dcc4cef1..021ffc5e16 100644
--- a/internal/service/chunk/chunk.go
+++ b/internal/service/chunk/chunk.go
@@ -162,6 +162,7 @@ func (s *ChunkService) RetrievalTest(ctx context.Context, req *service.Retrieval
if len(req.Datasets) == 0 {
return nil, fmt.Errorf("dataset_ids is required")
}
+ modelSolver := service.NewModelSolver()
tenants, err := s.userTenantDAO.GetByUserID(ctx, dao.DB, userID)
if err != nil {
@@ -243,14 +244,13 @@ func (s *ChunkService) RetrievalTest(ctx context.Context, req *service.Retrieval
if filter != nil {
method, _ := filter["method"].(string)
if method == "auto" || method == "semi_auto" {
- modelProviderSvc := service.NewModelProviderService()
if chatID != "" {
// Use chat_id from search_config (it's actually the model name)
- driver, mdlName, apiConfig, _, getErr := modelProviderSvc.ResolveModelConfig(ctx, tenantIDs[0], entity.ModelTypeChat, chatID)
+ target, getErr := modelSolver.ResolveModelConfig(ctx, tenantIDs[0], entity.ModelTypeChat, chatID)
if getErr != nil {
common.Warn("Failed to get chat model from search_config chat_id, using tenant default", zap.String("chatID", chatID), zap.Error(getErr))
} else {
- chatModelForFilter = models.NewChatModel(driver, &mdlName, apiConfig)
+ chatModelForFilter = models.NewChatModel(target.Driver, &target.ModelName, target.APIConfig)
common.Info("Fetched chat model (from search_config) for metadata filter",
zap.String("chatID", chatID),
zap.String("tenantID", tenantIDs[0]))
@@ -265,11 +265,11 @@ func (s *ChunkService) RetrievalTest(ctx context.Context, req *service.Retrieval
if err != nil || modelName == "" {
common.Warn("Failed to get tenant default chat model name for meta_data_filter", zap.Error(err))
} else {
- driver, mdlName, apiConfig, _, getErr := modelProviderSvc.ResolveModelConfig(ctx, tenantIDs[0], entity.ModelTypeChat, modelName)
+ target, getErr := modelSolver.ResolveModelConfig(ctx, tenantIDs[0], entity.ModelTypeChat, modelName)
if getErr != nil {
common.Warn("Failed to get chat model for meta_data_filter", zap.Error(getErr))
} else {
- chatModelForFilter = models.NewChatModel(driver, &mdlName, apiConfig)
+ chatModelForFilter = models.NewChatModel(target.Driver, &target.ModelName, target.APIConfig)
common.Info("Fetched chat model (tenant default) for metadata filter",
zap.String("tenantID", tenantIDs[0]),
zap.String("modelName", modelName))
@@ -305,17 +305,16 @@ func (s *ChunkService) RetrievalTest(ctx context.Context, req *service.Retrieval
var llmModelName string
if len(req.CrossLanguages) > 0 || (req.Keyword != nil && *req.Keyword) {
tenantSvc := service.NewTenantService()
- modelProviderSvc := service.NewModelProviderService()
var err error
llmModelName, err = tenantSvc.GetDefaultModelName(ctx, tenantIDs[0], entity.ModelTypeChat)
if err != nil || llmModelName == "" {
common.Warn("Failed to get default chat model name for LLM transformations", zap.Error(err))
} else {
- driver, mdlName, apiConfig, _, getErr := modelProviderSvc.ResolveModelConfig(ctx, tenantIDs[0], entity.ModelTypeChat, llmModelName)
+ target, getErr := modelSolver.ResolveModelConfig(ctx, tenantIDs[0], entity.ModelTypeChat, llmModelName)
if getErr != nil {
common.Warn("Failed to get chat model for LLM transformations", zap.Error(getErr))
} else {
- chatModel = models.NewChatModel(driver, &mdlName, apiConfig)
+ chatModel = models.NewChatModel(target.Driver, &target.ModelName, target.APIConfig)
common.Info("Fetched chat model (tenant default) for cross_languages/keyword_extraction",
zap.String("tenantID", tenantIDs[0]),
zap.String("modelName", llmModelName))
@@ -357,37 +356,35 @@ func (s *ChunkService) RetrievalTest(ctx context.Context, req *service.Retrieval
common.Debug("LabelQuestion result", zap.Any("labels", labels))
// Determine embedding model.
- modelProviderSvc := service.NewModelProviderService()
var embeddingModel *models.EmbeddingModel
var embdID string
+ var target *service.ModelTarget
+ var getErr error
if kbRecords[0].TenantEmbdID != nil && *kbRecords[0].TenantEmbdID != "" {
- driver, modelName, apiConfig, maxTokens, getErr := modelProviderSvc.GetModelConfigByID(ctx, tenantIDs[0], entity.ModelTypeEmbedding, *kbRecords[0].TenantEmbdID)
+ target, getErr = modelSolver.ResolveModelConfig(ctx, tenantIDs[0], entity.ModelTypeEmbedding, *kbRecords[0].TenantEmbdID)
if getErr != nil {
return nil, fmt.Errorf("failed to get embedding model by tenant_embd_id: %w", getErr)
}
- embeddingModel = models.NewEmbeddingModel(driver, &modelName, apiConfig, maxTokens)
} else if kbRecords[0].EmbdID != "" {
embdID = kbRecords[0].EmbdID
- driver, modelName, apiConfig, maxTokens, getErr := modelProviderSvc.ResolveModelConfig(ctx, tenantIDs[0], entity.ModelTypeEmbedding, embdID)
+ target, getErr = modelSolver.ResolveModelConfig(ctx, tenantIDs[0], entity.ModelTypeEmbedding, embdID)
if getErr != nil {
- _, embdID, err = dao.LookupTenantLLMByName(ctx, dao.DB, dao.NewTenantLLMDAO(), tenantIDs[0], kbRecords[0].EmbdID, entity.ModelTypeEmbedding)
+ _, embdID, err = dao.LookupTenantLLMByName(ctx, dao.DB, dao.NewTenantLLMDAO(), tenantIDs[0], embdID, entity.ModelTypeEmbedding)
if err != nil {
- return nil, fmt.Errorf("failed to get embedding model by embd_id: %w", getErr)
+ return nil, fmt.Errorf("failed to get embedding model by embd_id: %w", err)
}
- driver, modelName, apiConfig, maxTokens, getErr = modelProviderSvc.ResolveModelConfig(ctx, tenantIDs[0], entity.ModelTypeEmbedding, embdID)
+ target, getErr = modelSolver.ResolveModelConfig(ctx, tenantIDs[0], entity.ModelTypeEmbedding, embdID)
if getErr != nil {
return nil, fmt.Errorf("failed to get embedding model by embd_id: %w", getErr)
}
}
- embeddingModel = models.NewEmbeddingModel(driver, &modelName, apiConfig, maxTokens)
} else {
- driver, modelName, apiConfig, maxTokens, getErr := modelProviderSvc.GetTenantDefaultModelByType(ctx, tenantIDs[0], entity.ModelTypeEmbedding)
+ target, getErr = modelSolver.ResolveDefaultModelConfig(ctx, tenantIDs[0], entity.ModelTypeEmbedding)
if getErr != nil {
return nil, fmt.Errorf("failed to get tenant default embedding model: %w", getErr)
}
- embeddingModel = models.NewEmbeddingModel(driver, &modelName, apiConfig, maxTokens)
- embdID = fmt.Sprintf("%s@default", modelName)
}
+ embeddingModel = models.NewEmbeddingModel(target.Driver, &target.ModelName, target.APIConfig, target.MaxTokens)
if embeddingModel == nil {
return nil, fmt.Errorf("no embedding model found for tenant %s", tenantIDs[0])
@@ -395,23 +392,23 @@ func (s *ChunkService) RetrievalTest(ctx context.Context, req *service.Retrieval
common.Info("Fetched embedding model for retrieval",
zap.String("tenantID", tenantIDs[0]),
- zap.String("embdID", embdID))
+ zap.String("modelName", target.ModelName))
// Get rerank model if RerankID is specified
var rerankModel *models.RerankModel
if req.TenantRerankID != nil && *req.TenantRerankID != "" {
- driver, mdlName, apiConfig, maxTokens, getErr := modelProviderSvc.GetModelConfigByID(ctx, tenantIDs[0], entity.ModelTypeRerank, *req.TenantRerankID)
+ target, getErr := modelSolver.ResolveModelConfig(ctx, tenantIDs[0], entity.ModelTypeRerank, *req.TenantRerankID)
if getErr != nil {
return nil, fmt.Errorf("failed to get rerank model by tenant_rerank_id: %w", getErr)
}
- rerankModel = models.NewRerankModel(driver, &mdlName, apiConfig, maxTokens)
+ rerankModel = models.NewRerankModel(target.Driver, &target.ModelName, target.APIConfig, target.MaxTokens)
} else if req.RerankID != nil && *req.RerankID != "" {
rerankCompositeName := *req.RerankID
- driver, mdlName, apiConfig, maxTokens, getErr := modelProviderSvc.ResolveModelConfig(ctx, tenantIDs[0], entity.ModelTypeRerank, rerankCompositeName)
+ target, getErr := modelSolver.ResolveModelConfig(ctx, tenantIDs[0], entity.ModelTypeRerank, rerankCompositeName)
if getErr != nil {
rerankModel = nil
} else {
- rerankModel = models.NewRerankModel(driver, &mdlName, apiConfig, maxTokens)
+ rerankModel = models.NewRerankModel(target.Driver, &target.ModelName, target.APIConfig, target.MaxTokens)
}
}
diff --git a/internal/service/dataset/crud.go b/internal/service/dataset/crud.go
index 8ae755cea3..af79ef61b8 100644
--- a/internal/service/dataset/crud.go
+++ b/internal/service/dataset/crud.go
@@ -144,9 +144,9 @@ func (d *DatasetService) CreateDataset(ctx context.Context, req *service.CreateD
tenantEmbdID = ""
}
if embdID != "" && tenantEmbdID == "" {
- resolvedID, err := service.NewModelProviderService().ResolveModelID(ctx, tenantID, entity.ModelTypeEmbedding, embdID)
+ target, err := service.NewModelSolver().ResolveModelConfig(ctx, tenantID, entity.ModelTypeEmbedding, embdID)
if err == nil {
- tenantEmbdID = resolvedID
+ tenantEmbdID = target.ModelID
} else {
return nil, common.CodeDataError, err
}
diff --git a/internal/service/dataset/embedding.go b/internal/service/dataset/embedding.go
index b654dcb3fe..3ffac7502b 100644
--- a/internal/service/dataset/embedding.go
+++ b/internal/service/dataset/embedding.go
@@ -60,11 +60,11 @@ func (d *DatasetService) CheckEmbedding(ctx context.Context, userID, datasetID s
return nil, common.CodeServerError, errors.New("doc engine not initialized")
}
- driver, modelName, apiConfig, maxTokens, err := service.NewModelProviderService().ResolveModelConfig(ctx, kb.TenantID, entity.ModelTypeEmbedding, embeddingID)
+ target, err := service.NewModelSolver().ResolveModelConfig(ctx, kb.TenantID, entity.ModelTypeEmbedding, embeddingID)
if err != nil {
return nil, common.CodeDataError, err
}
- embeddingModel := models.NewEmbeddingModel(driver, &modelName, apiConfig, maxTokens)
+ embeddingModel := models.NewEmbeddingModel(target.Driver, &target.ModelName, target.APIConfig, target.MaxTokens)
checkNum := defaultEmbeddingCheckNum
if req.CheckNum != nil {
@@ -281,7 +281,7 @@ func (d *DatasetService) sampleRandomChunksWithVectors(ctx context.Context, tena
}
func (d *DatasetService) verifyEmbeddingAvailability(ctx context.Context, embdID string, tenantID string) (bool, string) {
- _, _, _, _, err := service.NewModelProviderService().ResolveModelConfig(ctx, tenantID, entity.ModelTypeEmbedding, embdID)
+ _, err := service.NewModelSolver().ResolveModelConfig(ctx, tenantID, entity.ModelTypeEmbedding, embdID)
if err != nil {
return false, err.Error()
}
diff --git a/internal/service/dataset/search.go b/internal/service/dataset/search.go
index 237c19ae65..630dee101e 100644
--- a/internal/service/dataset/search.go
+++ b/internal/service/dataset/search.go
@@ -105,7 +105,7 @@ func (d *DatasetService) SearchDatasets(ctx context.Context, req *service.Search
documentIDs = req.DocIDs
}
- modelProviderSvc := service.NewModelProviderService()
+ modelSolver := service.NewModelSolver()
// Access check for all datasets
var tenantIDs []string
@@ -212,20 +212,20 @@ func (d *DatasetService) SearchDatasets(ctx context.Context, req *service.Search
method, _ := metadataFilter["method"].(string)
if method == "auto" || method == "semi_auto" {
if chatID != "" {
- driver, modelName, apiConfig, _, err := modelProviderSvc.ResolveModelConfig(ctx, tenantIDs[0], entity.ModelTypeChat, chatID)
+ target, err := modelSolver.ResolveModelConfig(ctx, tenantIDs[0], entity.ModelTypeChat, chatID)
if err != nil {
common.Warn("Failed to get chat model config from search_config chat_id, using tenant default", zap.String("chatID", chatID), zap.Error(err))
} else {
- chatModelForFilter = modelModule.NewChatModel(driver, &modelName, apiConfig)
+ chatModelForFilter = modelModule.NewChatModel(target.Driver, &target.ModelName, target.APIConfig)
}
}
if chatModelForFilter == nil {
- driver, modelName, apiConfig, _, err := modelProviderSvc.GetTenantDefaultModelByType(ctx, tenantIDs[0], entity.ModelTypeChat)
+ target, err := modelSolver.ResolveDefaultModelConfig(ctx, tenantIDs[0], entity.ModelTypeChat)
if err != nil {
common.Warn("Failed to get tenant default chat model for meta_data_filter", zap.Error(err))
} else {
- chatModelForFilter = modelModule.NewChatModel(driver, &modelName, apiConfig)
+ chatModelForFilter = modelModule.NewChatModel(target.Driver, &target.ModelName, target.APIConfig)
}
}
}
@@ -256,11 +256,11 @@ func (d *DatasetService) SearchDatasets(ctx context.Context, req *service.Search
}
}
if keyword {
- driver, modelName, apiConfig, _, err := modelProviderSvc.GetTenantDefaultModelByType(ctx, tenantIDs[0], entity.ModelTypeChat)
+ target, err := modelSolver.ResolveDefaultModelConfig(ctx, tenantIDs[0], entity.ModelTypeChat)
if err != nil {
common.Warn("Failed to get default chat model for LLM transformations", zap.Error(err))
} else {
- chatModel := modelModule.NewChatModel(driver, &modelName, apiConfig)
+ chatModel := modelModule.NewChatModel(target.Driver, &target.ModelName, target.APIConfig)
extractedKeywords, err := service.KeywordExtraction(ctx, chatModel, modifiedQuestion, 3)
if err != nil {
common.Warn("Failed to extract keywords from question", zap.Error(err))
@@ -277,21 +277,21 @@ func (d *DatasetService) SearchDatasets(ctx context.Context, req *service.Search
// Determine embedding model
var embeddingModel *modelModule.EmbeddingModel
if kbRecords[0].EmbdID != "" {
- driver, modelName, apiConfig, maxTokens, embErr := modelProviderSvc.ResolveModelConfig(ctx, tenantIDs[0], entity.ModelTypeEmbedding, kbRecords[0].EmbdID)
+ target, embErr := modelSolver.ResolveModelConfig(ctx, tenantIDs[0], entity.ModelTypeEmbedding, kbRecords[0].EmbdID)
if embErr != nil {
return nil, fmt.Errorf("failed to get embedding model by embd_id: %w", embErr)
}
- embeddingModel = modelModule.NewEmbeddingModel(driver, &modelName, apiConfig, maxTokens)
+ embeddingModel = modelModule.NewEmbeddingModel(target.Driver, &target.ModelName, target.APIConfig, target.MaxTokens)
}
// Get rerank model if rerankID is specified
var rerankModel *modelModule.RerankModel
if rerankID != "" {
- driver, modelName, apiConfig, maxTokens, rErr := modelProviderSvc.ResolveModelConfig(ctx, tenantIDs[0], entity.ModelTypeRerank, rerankID)
+ target, rErr := modelSolver.ResolveModelConfig(ctx, tenantIDs[0], entity.ModelTypeRerank, rerankID)
if rErr != nil {
return nil, fmt.Errorf("failed to get rerank model by rerank_id: %w", rErr)
}
- rerankModel = modelModule.NewRerankModel(driver, &modelName, apiConfig, maxTokens)
+ rerankModel = modelModule.NewRerankModel(target.Driver, &target.ModelName, target.APIConfig, target.MaxTokens)
}
retrievalReq := &nlp.RetrievalRequest{
diff --git a/internal/service/dataset/update.go b/internal/service/dataset/update.go
index 2db7d151e6..3fb86e9b7b 100644
--- a/internal/service/dataset/update.go
+++ b/internal/service/dataset/update.go
@@ -223,9 +223,9 @@ func (d *DatasetService) UpdateDataset(ctx context.Context, datasetID, tenantID
return errors.New(message)
}
if effectiveEmbdID != "" && tenantEmbdID == "" {
- resolvedID, err := service.NewModelProviderService().ResolveModelID(ctx, tenantID, entity.ModelTypeEmbedding, effectiveEmbdID)
+ target, err := service.NewModelSolver().ResolveModelConfig(ctx, tenantID, entity.ModelTypeEmbedding, effectiveEmbdID)
if err == nil {
- tenantEmbdID = resolvedID
+ tenantEmbdID = target.ModelID
}
}
updates["embd_id"] = effectiveEmbdID
diff --git a/internal/service/generator.go b/internal/service/generator.go
index 5789e4f35a..9f4241941c 100644
--- a/internal/service/generator.go
+++ b/internal/service/generator.go
@@ -106,12 +106,12 @@ func CrossLanguages(ctx context.Context, tenantID string, llmID string, query st
zap.String("llmID", llmID),
zap.Strings("languages", languages))
- modelProviderSvc := NewModelProviderService()
+ modelSolver := NewModelSolver()
var chatModel *modelModule.ChatModel
var err error
if llmID != "" {
- modelTypes, err := modelProviderSvc.ResolveModelType(ctx, tenantID, llmID)
+ modelTypes, err := modelSolver.ResolveModelType(ctx, tenantID, llmID)
if err != nil {
return query, fmt.Errorf("failed to get model type: %w", err)
}
@@ -122,17 +122,17 @@ func CrossLanguages(ctx context.Context, tenantID string, llmID string, query st
break
}
}
- driver, modelName, apiConfig, _, err := modelProviderSvc.ResolveModelConfig(ctx, tenantID, resolvedType, llmID)
+ target, err := modelSolver.ResolveModelConfig(ctx, tenantID, resolvedType, llmID)
if err != nil {
return query, fmt.Errorf("failed to get chat model: %w", err)
}
- chatModel = modelModule.NewChatModel(driver, &modelName, apiConfig)
+ chatModel = modelModule.NewChatModel(target.Driver, &target.ModelName, target.APIConfig)
} else {
- driver, modelName, apiConfig, _, err := modelProviderSvc.GetTenantDefaultModelByType(ctx, tenantID, entity.ModelTypeChat)
+ target, err := modelSolver.ResolveDefaultModelConfig(ctx, tenantID, entity.ModelTypeChat)
if err != nil {
return query, fmt.Errorf("failed to get default chat model: %w", err)
}
- chatModel = modelModule.NewChatModel(driver, &modelName, apiConfig)
+ chatModel = modelModule.NewChatModel(target.Driver, &target.ModelName, target.APIConfig)
}
if chatModel == nil {
return query, fmt.Errorf("failed to get chat model: nil chat model")
diff --git a/internal/service/memory.go b/internal/service/memory.go
index cc03263b74..f3203f4ccb 100644
--- a/internal/service/memory.go
+++ b/internal/service/memory.go
@@ -379,20 +379,22 @@ func (s *MemoryService) CreateMemory(ctx context.Context, tenantID string, req *
// Resolve tenant model IDs, mirroring Python's ensure_tenant_model_ids_for_params.
// Resolution failure is non-fatal (e.g. Builtin models that have no
// tenant_model row) — we leave the tenant_*_id fields nil and proceed.
- modelProvider := NewModelProviderService()
+ modelSolver := NewModelSolver()
if req.LLMID != "" && req.TenantLLMID == nil {
- tenantLLMID, err := modelProvider.ResolveModelID(ctx, tenantID, entity.ModelTypeChat, req.LLMID)
+ target, err := modelSolver.ResolveModelConfig(ctx, tenantID, entity.ModelTypeChat, req.LLMID)
if err != nil {
slog.Warn("CreateMemory: failed to resolve tenant LLM id", "tenant_id", tenantID, "llm_id", req.LLMID, "err", err)
- } else if tenantLLMID != "" {
+ } else if target != nil && target.ModelID != "" {
+ tenantLLMID := target.ModelID
req.TenantLLMID = &tenantLLMID
}
}
if req.EmbdID != "" && req.TenantEmbdID == nil {
- tenantEmbdID, err := modelProvider.ResolveModelID(ctx, tenantID, entity.ModelTypeEmbedding, req.EmbdID)
+ target, err := modelSolver.ResolveModelConfig(ctx, tenantID, entity.ModelTypeEmbedding, req.EmbdID)
if err != nil {
slog.Warn("CreateMemory: failed to resolve tenant embedding id", "tenant_id", tenantID, "embd_id", req.EmbdID, "err", err)
- } else if tenantEmbdID != "" {
+ } else if target != nil && target.ModelID != "" {
+ tenantEmbdID := target.ModelID
req.TenantEmbdID = &tenantEmbdID
}
}
@@ -529,15 +531,15 @@ func (s *MemoryService) UpdateMemory(ctx context.Context, tenantID string, memor
// tenant_model row IDs so downstream code that depends on
// tenant_llm_id / tenant_embd_id stays consistent after an update.
// Resolution failure is non-fatal (e.g. Builtin models).
- modelProvider := NewModelProviderService()
+ modelSolver := NewModelSolver()
if req.LLMID != nil {
updateDict["llm_id"] = *req.LLMID
if req.TenantLLMID == nil && *req.LLMID != "" {
- resolved, err := modelProvider.ResolveModelID(ctx, ownerTenantID, entity.ModelTypeChat, *req.LLMID)
+ target, err := modelSolver.ResolveModelConfig(ctx, ownerTenantID, entity.ModelTypeChat, *req.LLMID)
if err != nil {
slog.Warn("UpdateMemory: failed to resolve tenant LLM id", "tenant_id", ownerTenantID, "llm_id", *req.LLMID, "err", err)
- } else if resolved != "" {
- updateDict["tenant_llm_id"] = resolved
+ } else if target != nil && target.ModelID != "" {
+ updateDict["tenant_llm_id"] = target.ModelID
}
}
}
@@ -545,11 +547,11 @@ func (s *MemoryService) UpdateMemory(ctx context.Context, tenantID string, memor
if req.EmbdID != nil {
updateDict["embd_id"] = *req.EmbdID
if req.TenantEmbdID == nil && *req.EmbdID != "" {
- resolved, err := modelProvider.ResolveModelID(ctx, ownerTenantID, entity.ModelTypeEmbedding, *req.EmbdID)
+ target, err := modelSolver.ResolveModelConfig(ctx, ownerTenantID, entity.ModelTypeEmbedding, *req.EmbdID)
if err != nil {
slog.Warn("UpdateMemory: failed to resolve tenant embedding id", "tenant_id", ownerTenantID, "embd_id", *req.EmbdID, "err", err)
- } else if resolved != "" {
- updateDict["tenant_embd_id"] = resolved
+ } else if target != nil && target.ModelID != "" {
+ updateDict["tenant_embd_id"] = target.ModelID
}
}
}
@@ -1402,11 +1404,11 @@ func memoryFusionWeights(keywordsSimilarityWeight float64) string {
}
func (s *MemoryService) memoryMessageDenseExpr(ctx context.Context, question string, memory *entity.Memory, topN int, similarityThreshold float64) (*enginetypes.MatchDenseExpr, error) {
- driver, modelName, apiConfig, maxTokens, err := NewModelProviderService().ResolveModelConfig(ctx, memory.TenantID, entity.ModelTypeEmbedding, memory.EmbdID)
+ target, err := NewModelSolver().ResolveModelConfig(ctx, memory.TenantID, entity.ModelTypeEmbedding, memory.EmbdID)
if err != nil {
return nil, err
}
- embeddingModel := models.NewEmbeddingModel(driver, &modelName, apiConfig, maxTokens)
+ embeddingModel := models.NewEmbeddingModel(target.Driver, &target.ModelName, target.APIConfig, target.MaxTokens)
// Query: true — the memory store is searched by question (Python
// memory/services/query.py uses emb_mdl.encode_queries).
embeddings, err := embeddingModel.ModelDriver.Embed(ctx, embeddingModel.ModelName, models.EmbedRequest{Texts: []string{question}, Query: true}, embeddingModel.APIConfig, &models.EmbeddingConfig{Dimension: 0}, nil)
diff --git a/internal/service/memory_extractor.go b/internal/service/memory_extractor.go
index 4e07195848..e5b08c3809 100644
--- a/internal/service/memory_extractor.go
+++ b/internal/service/memory_extractor.go
@@ -474,15 +474,15 @@ func (s *MemoryMessageService) extractByLLM(ctx context.Context, mem *CreateMemo
if mem.TenantLLMID != nil && *mem.TenantLLMID != "" {
llmRef = *mem.TenantLLMID
}
- driver, modelName, apiConfig, _, err := NewModelProviderService().ResolveModelConfig(ctx, mem.TenantID, entity.ModelTypeChat, llmRef)
+ target, err := NewModelSolver().ResolveModelConfig(ctx, mem.TenantID, entity.ModelTypeChat, llmRef)
if err != nil {
return nil, fmt.Errorf("resolve chat model: %w", classifyMemoryTaskDependencyError(err))
}
- chatModel := models.NewChatModel(driver, &modelName, apiConfig)
+ chatModel := models.NewChatModel(target.Driver, &target.ModelName, target.APIConfig)
_ = s.updateTaskProgress(ctx, taskID, 0.15, "Prepared prompts and LLM.")
temperature := mem.Temperature
- resp, err := chatModel.ModelDriver.ChatWithMessages(ctx, modelName, messages, apiConfig, &models.ChatConfig{Temperature: &temperature}, nil)
+ resp, err := chatModel.ModelDriver.ChatWithMessages(ctx, target.ModelName, messages, target.APIConfig, &models.ChatConfig{Temperature: &temperature}, nil)
if err != nil {
return nil, fmt.Errorf("chat model: %w", err)
}
diff --git a/internal/service/memory_message_service.go b/internal/service/memory_message_service.go
index b42a892c76..548b843ee6 100644
--- a/internal/service/memory_message_service.go
+++ b/internal/service/memory_message_service.go
@@ -324,11 +324,11 @@ func (s *MemoryMessageService) embedAndSaveMessages(ctx context.Context, mem *Cr
for i, message := range messages {
contents[i], _ = message["content"].(string)
}
- driver, modelName, apiConfig, maxTokens, err := NewModelProviderService().ResolveModelConfig(ctx, mem.TenantID, entity.ModelTypeEmbedding, mem.EmbdID)
+ target, err := NewModelSolver().ResolveModelConfig(ctx, mem.TenantID, entity.ModelTypeEmbedding, mem.EmbdID)
if err != nil {
return err
}
- embeddingModel := models.NewEmbeddingModel(driver, &modelName, apiConfig, maxTokens)
+ embeddingModel := models.NewEmbeddingModel(target.Driver, &target.ModelName, target.APIConfig, target.MaxTokens)
embeddings, err := embeddingModel.ModelDriver.Embed(ctx, embeddingModel.ModelName, models.EmbedRequest{Texts: contents}, embeddingModel.APIConfig, &models.EmbeddingConfig{Dimension: 0}, nil)
if err != nil {
return err
diff --git a/internal/service/model_call.go b/internal/service/model_call.go
new file mode 100644
index 0000000000..cc53925b3b
--- /dev/null
+++ b/internal/service/model_call.go
@@ -0,0 +1,375 @@
+//
+// Copyright 2026 The InfiniFlow Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+package service
+
+import (
+ "context"
+ "errors"
+ "fmt"
+ "strings"
+
+ "gorm.io/gorm"
+
+ "ragflow/internal/common"
+ "ragflow/internal/dao"
+ "ragflow/internal/entity"
+ modelModule "ragflow/internal/entity/models"
+)
+
+// ModelCallService provides the model-call API described in Model方法.pdf.
+// It accepts only the caller identity, model reference, request data, and
+// runtime configuration. Provider, instance, API configuration, and driver
+// resolution are handled internally.
+//
+// The legacy methods on ModelProviderService remain untouched so this new API
+// can be introduced without changing existing callers.
+type ModelCallService struct {
+ providerService *ModelProviderService
+ modelSolver *ModelSolver
+}
+
+// NewModelCallService creates a model-call service with the standard model
+// provider and model resolver.
+func NewModelCallService() *ModelCallService {
+ providerService := NewModelProviderService()
+ return &ModelCallService{
+ providerService: providerService,
+ modelSolver: &ModelSolver{service: providerService},
+ }
+}
+
+// ChatToModelWithMessages sends messages to the model selected by modelRef.
+func (s *ModelCallService) ChatToModelWithMessages(ctx context.Context, modelRef, userID string, messages []modelModule.Message, config *modelModule.ChatConfig, usage *common.ModelUsage) (*modelModule.ChatResponse, common.ErrorCode, error) {
+ target, tenantID, code, err := s.resolveTarget(ctx, modelRef, userID, entity.ModelTypeChat)
+ if err != nil {
+ return nil, code, err
+ }
+ if config == nil {
+ config = &modelModule.ChatConfig{}
+ }
+ if target.ModelInfo != nil {
+ config.ModelClass = target.ModelInfo.Class
+ if config.Thinking == nil && target.ModelInfo.Thinking != nil {
+ thinking := target.ModelInfo.Thinking.DefaultValue
+ config.Thinking = &thinking
+ }
+ }
+ populateModelUsage(usage, target, tenantID, userID)
+
+ modelName := target.ModelName
+ response, err := target.Driver.ChatWithMessages(ctx, modelName, messages, target.APIConfig, config, usage)
+ if err != nil {
+ return nil, common.CodeServerError, err
+ }
+ if response == nil {
+ return nil, common.CodeServerError, errors.New("empty chat response")
+ }
+ return response, common.CodeSuccess, nil
+}
+
+// ChatToModelStreamWithSender streams the response from the model selected by
+// modelRef through sender.
+func (s *ModelCallService) ChatToModelStreamWithSender(ctx context.Context, modelRef, userID string, messages []modelModule.Message, config *modelModule.ChatConfig, usage *common.ModelUsage, sender func(*string, *string) error) (common.ErrorCode, error) {
+ target, tenantID, code, err := s.resolveTarget(ctx, modelRef, userID, entity.ModelTypeChat)
+ if err != nil {
+ return code, err
+ }
+ if config == nil {
+ config = &modelModule.ChatConfig{}
+ }
+ if target.ModelInfo != nil {
+ config.ModelClass = target.ModelInfo.Class
+ if config.Thinking == nil && target.ModelInfo.Thinking != nil {
+ thinking := target.ModelInfo.Thinking.DefaultValue
+ config.Thinking = &thinking
+ }
+ }
+ populateModelUsage(usage, target, tenantID, userID)
+
+ modelName := target.ModelName
+ if err := target.Driver.ChatStreamlyWithSender(ctx, modelName, messages, target.APIConfig, config, usage, sender); err != nil {
+ return common.CodeServerError, err
+ }
+ return common.CodeSuccess, nil
+}
+
+// EmbedText embeds texts with the model selected by modelRef.
+func (s *ModelCallService) EmbedText(ctx context.Context, modelRef, userID string, texts []string, config *modelModule.EmbeddingConfig) ([]modelModule.EmbeddingData, common.ErrorCode, error) {
+ target, _, code, err := s.resolveTarget(ctx, modelRef, userID, entity.ModelTypeEmbedding)
+ if err != nil {
+ return nil, code, err
+ }
+ if config == nil {
+ config = &modelModule.EmbeddingConfig{}
+ }
+ if err := validateEmbeddingModel(target.ModelInfo, config.Dimension, len(texts)); err != nil {
+ return nil, common.CodeBadRequest, err
+ }
+
+ modelName := target.ModelName
+ embeddings, err := target.Driver.Embed(ctx, &modelName, modelModule.EmbedRequest{Texts: texts}, target.APIConfig, config, nil)
+ if err != nil {
+ return nil, common.CodeServerError, err
+ }
+ if len(embeddings) == 0 {
+ return nil, common.CodeServerError, errors.New("empty embed response")
+ }
+ return embeddings, common.CodeSuccess, nil
+}
+
+// RerankDocument reranks documents with the model selected by modelRef.
+func (s *ModelCallService) RerankDocument(ctx context.Context, modelRef, userID, query string, documents []string, config *modelModule.RerankConfig) (*modelModule.RerankResponse, common.ErrorCode, error) {
+ target, _, code, err := s.resolveTarget(ctx, modelRef, userID, entity.ModelTypeRerank)
+ if err != nil {
+ return nil, code, err
+ }
+ if config == nil {
+ config = &modelModule.RerankConfig{}
+ }
+
+ modelName := target.ModelName
+ rerankModel := modelModule.NewRerankModel(target.Driver, &modelName, target.APIConfig, target.MaxTokens)
+ response, err := rerankModel.Rerank(ctx, modelModule.RerankRequest{Query: query, Documents: documents}, target.APIConfig, config, nil)
+ if err != nil {
+ return nil, common.CodeServerError, err
+ }
+ if response == nil {
+ return nil, common.CodeServerError, errors.New("empty rerank response")
+ }
+ return response, common.CodeSuccess, nil
+}
+
+// TranscribeAudio converts audioFile to text with the model selected by
+// modelRef.
+func (s *ModelCallService) TranscribeAudio(ctx context.Context, modelRef, userID string, audioFile *string, config *modelModule.ASRConfig) (*modelModule.ASRResponse, common.ErrorCode, error) {
+ target, _, code, err := s.resolveTarget(ctx, modelRef, userID, entity.ModelTypeSpeech2Text)
+ if err != nil {
+ return nil, code, err
+ }
+ if config == nil {
+ config = &modelModule.ASRConfig{}
+ }
+
+ modelName := target.ModelName
+ response, err := target.Driver.TranscribeAudio(ctx, &modelName, audioFile, target.APIConfig, config, nil)
+ if err != nil {
+ return nil, common.CodeServerError, err
+ }
+ if response == nil {
+ return nil, common.CodeServerError, errors.New("empty transcribe response")
+ }
+ return response, common.CodeSuccess, nil
+}
+
+// TranscribeAudioStream streams the transcription from the model selected by
+// modelRef through sender.
+func (s *ModelCallService) TranscribeAudioStream(ctx context.Context, modelRef, userID string, audioFile *string, config *modelModule.ASRConfig, sender func(*string, *string) error) (common.ErrorCode, error) {
+ target, _, code, err := s.resolveTarget(ctx, modelRef, userID, entity.ModelTypeSpeech2Text)
+ if err != nil {
+ return code, err
+ }
+ if config == nil {
+ config = &modelModule.ASRConfig{}
+ }
+
+ modelName := target.ModelName
+ if err := target.Driver.TranscribeAudioWithSender(ctx, &modelName, audioFile, target.APIConfig, config, nil, sender); err != nil {
+ return common.CodeServerError, err
+ }
+ return common.CodeSuccess, nil
+}
+
+// AudioSpeech converts audioContent to speech with the model selected by
+// modelRef.
+func (s *ModelCallService) AudioSpeech(ctx context.Context, modelRef, userID string, audioContent *string, config *modelModule.TTSConfig) (*modelModule.TTSResponse, common.ErrorCode, error) {
+ target, _, code, err := s.resolveTarget(ctx, modelRef, userID, entity.ModelTypeTTS)
+ if err != nil {
+ return nil, code, err
+ }
+ if config == nil {
+ config = &modelModule.TTSConfig{}
+ }
+
+ modelName := target.ModelName
+ response, err := target.Driver.AudioSpeech(ctx, &modelName, audioContent, target.APIConfig, config, nil)
+ if err != nil {
+ return nil, common.CodeServerError, err
+ }
+ if response == nil {
+ return nil, common.CodeServerError, errors.New("empty audio speech response")
+ }
+ return response, common.CodeSuccess, nil
+}
+
+// AudioSpeechStream streams synthesized audio from the model selected by
+// modelRef through sender.
+func (s *ModelCallService) AudioSpeechStream(ctx context.Context, modelRef, userID string, audioContent *string, config *modelModule.TTSConfig, sender func(*string, *string) error) (common.ErrorCode, error) {
+ target, _, code, err := s.resolveTarget(ctx, modelRef, userID, entity.ModelTypeTTS)
+ if err != nil {
+ return code, err
+ }
+ if config == nil {
+ config = &modelModule.TTSConfig{}
+ }
+
+ modelName := target.ModelName
+ if err := target.Driver.AudioSpeechWithSender(ctx, &modelName, audioContent, target.APIConfig, config, nil, sender); err != nil {
+ return common.CodeServerError, err
+ }
+ return common.CodeSuccess, nil
+}
+
+// OCRFile extracts text from content or url with the model selected by
+// modelRef.
+func (s *ModelCallService) OCRFile(ctx context.Context, modelRef, userID string, content []byte, url *string, config *modelModule.OCRConfig) (*modelModule.OCRFileResponse, common.ErrorCode, error) {
+ target, _, code, err := s.resolveTarget(ctx, modelRef, userID, entity.ModelTypeOCR)
+ if err != nil {
+ return nil, code, err
+ }
+ if config == nil {
+ config = &modelModule.OCRConfig{}
+ }
+
+ modelName := target.ModelName
+ response, err := target.Driver.OCRFile(ctx, &modelName, content, url, target.APIConfig, config, nil)
+ if err != nil {
+ return nil, common.CodeServerError, err
+ }
+ if response == nil {
+ return nil, common.CodeServerError, errors.New("empty OCR response")
+ }
+ return response, common.CodeSuccess, nil
+}
+
+// ParseFile parses content or url with the document parser selected by
+// modelRef. doc_parse is a provider catalog capability rather than a member
+// of entity.ModelType, so this method uses the existing model-info resolver.
+func (s *ModelCallService) ParseFile(ctx context.Context, modelRef, userID string, content []byte, url *string, config *modelModule.ParseFileConfig) (*modelModule.ParseFileResponse, common.ErrorCode, error) {
+ info, err := s.resolveModelInfo(ctx, modelRef, userID)
+ if err != nil {
+ return nil, common.CodeNotFound, err
+ }
+ if info.ModelInfo == nil || !info.ModelInfo.ModelTypeMap["doc_parse"] {
+ return nil, common.CodeNotFound, fmt.Errorf("model %q is not a document parser", modelRef)
+ }
+ if config == nil {
+ config = &modelModule.ParseFileConfig{}
+ }
+
+ modelDriver := info.ProviderInfo.ModelDriver
+ if info.ModelEntity != nil {
+ if info.ModelEntity.Status != "active" {
+ return nil, common.CodeNotFound, errors.New("model is inactive")
+ }
+ region := ""
+ baseURL := ""
+ if info.APIConfig != nil {
+ if info.APIConfig.Region != nil {
+ region = *info.APIConfig.Region
+ }
+ if info.APIConfig.BaseURL != nil {
+ baseURL = *info.APIConfig.BaseURL
+ }
+ }
+ modelDriver, err = newModelDriverForBaseURL(info.ProviderInfo.ModelDriver, info.ProviderEntity.ProviderName, region, baseURL)
+ if err != nil {
+ return nil, common.CodeServerError, err
+ }
+ }
+
+ modelName := info.ModelInfo.Name
+ if info.ModelEntity != nil && info.ModelEntity.ModelName != "" {
+ modelName = info.ModelEntity.ModelName
+ }
+ response, err := modelDriver.ParseFile(ctx, &modelName, content, url, info.APIConfig, config, nil)
+ if err != nil {
+ return nil, common.CodeServerError, err
+ }
+ if response == nil {
+ return nil, common.CodeServerError, errors.New("empty parse file response")
+ }
+ return response, common.CodeSuccess, nil
+}
+
+func (s *ModelCallService) resolveTarget(ctx context.Context, modelRef, userID string, modelType entity.ModelType) (*ModelTarget, string, common.ErrorCode, error) {
+ if s == nil || s.providerService == nil || s.modelSolver == nil {
+ return nil, "", common.CodeServerError, errors.New("model call service is not initialized")
+ }
+ tenantID, err := s.ownerTenantID(ctx, userID)
+ if err != nil {
+ return nil, "", common.CodeNotFound, err
+ }
+ target, err := s.modelSolver.ResolveModelConfig(ctx, tenantID, modelType, modelRef)
+ if err != nil {
+ return nil, "", common.CodeNotFound, err
+ }
+ return target, tenantID, common.CodeSuccess, nil
+}
+
+func (s *ModelCallService) ownerTenantID(ctx context.Context, userID string) (string, error) {
+ if strings.TrimSpace(userID) == "" {
+ return "", errors.New("user id is required")
+ }
+ if s.providerService.userTenantDAO == nil {
+ return "", errors.New("user tenant service is not initialized")
+ }
+ tenants, err := s.providerService.userTenantDAO.GetByUserIDAndRole(ctx, dao.DB, userID, "owner")
+ if err != nil {
+ return "", err
+ }
+ if len(tenants) == 0 || tenants[0] == nil || strings.TrimSpace(tenants[0].TenantID) == "" {
+ return "", fmt.Errorf("no owner tenant found for user %s", userID)
+ }
+ return tenants[0].TenantID, nil
+}
+
+func populateModelUsage(usage *common.ModelUsage, target *ModelTarget, tenantID, userID string) {
+ if usage == nil {
+ return
+ }
+ usage.UserID = userID
+ usage.TenantID = tenantID
+ usage.ProviderName = target.ProviderName
+ usage.ModelName = target.ModelName
+ if target.APIConfig != nil && target.APIConfig.ApiKey != nil {
+ usage.APIKey = *target.APIConfig.ApiKey
+ }
+}
+
+func (s *ModelCallService) resolveModelInfo(ctx context.Context, modelRef, userID string) (*ModelInstanceAndProviderInfo, error) {
+ if s == nil || s.providerService == nil {
+ return nil, errors.New("model call service is not initialized")
+ }
+ modelRef = strings.TrimSpace(modelRef)
+ if modelRef == "" {
+ return nil, errors.New("model ref is required")
+ }
+
+ model, err := s.providerService.modelDAO.GetByID(ctx, dao.DB, modelRef)
+ if err == nil && model != nil {
+ return s.providerService.getModelInstanceAndProviderByID(ctx, &modelRef, userID, nil)
+ }
+ if err != nil && !errors.Is(err, gorm.ErrRecordNotFound) {
+ return nil, err
+ }
+
+ modelName, instanceName, providerName, err := parseModelName(modelRef)
+ if err != nil {
+ return nil, err
+ }
+ return s.providerService.getModelInstanceAndProviderByName(ctx, &providerName, &instanceName, &modelName, userID, nil)
+}
diff --git a/internal/service/model_service.go b/internal/service/model_service.go
index 2070879112..baa4bf5d00 100644
--- a/internal/service/model_service.go
+++ b/internal/service/model_service.go
@@ -93,7 +93,7 @@ func parseModelName(compositeName string) (modelName, instanceName, providerName
// splitRightAnchoredModelName is a bare-name-tolerant variant of
// parseModelName used by the Builtin / TEI short-circuit branches in
-// GetModelConfigFromProviderInstance.
+// model resolution.
//
// Those branches must accept a bare model name (no provider suffix) where
// parseModelName would return an error, while still preserving any '@'
@@ -3249,7 +3249,7 @@ func (m *ModelProviderService) AudioSpeech(ctx context.Context, providerName, in
// always resolves get_tenant_default_model_by_type(LLMType.TTS).
// A missing default surfaces as a typed error ("no default tts
// model is set") instead of a nil-pointer panic.
- driver, name, defaultConfig, _, derr := m.GetTenantDefaultModelByType(ctx, userID, entity.ModelTypeTTS)
+ target, derr := m.modelSolver().ResolveDefaultModelConfig(ctx, userID, entity.ModelTypeTTS)
if derr != nil {
return nil, common.CodeNotFound, derr
}
@@ -3257,7 +3257,7 @@ func (m *ModelProviderService) AudioSpeech(ctx context.Context, providerName, in
modelConfig = &modelModule.TTSConfig{}
}
var response *modelModule.TTSResponse
- response, derr = driver.AudioSpeech(ctx, &name, audioContent, defaultConfig, modelConfig, nil)
+ response, derr = target.Driver.AudioSpeech(ctx, &target.ModelName, audioContent, target.APIConfig, modelConfig, nil)
if derr != nil {
return nil, common.CodeServerError, derr
}
@@ -3476,29 +3476,29 @@ func (m *ModelProviderService) ParseFile(ctx context.Context, providerName, inst
// GetEmbeddingModel returns an EmbeddingModel wrapper for the given tenant
func (m *ModelProviderService) GetEmbeddingModel(ctx context.Context, tenantID, compositeModelName string) (*modelModule.EmbeddingModel, error) {
- driver, modelName, apiConfig, maxTokens, err := m.ResolveModelConfig(ctx, tenantID, entity.ModelTypeEmbedding, compositeModelName)
+ target, err := m.modelSolver().ResolveModelConfig(ctx, tenantID, entity.ModelTypeEmbedding, compositeModelName)
if err != nil {
return nil, err
}
- return modelModule.NewEmbeddingModel(driver, &modelName, apiConfig, maxTokens), nil
+ return modelModule.NewEmbeddingModel(target.Driver, &target.ModelName, target.APIConfig, target.MaxTokens), nil
}
// GetChatModel returns a ChatModel wrapper for the given tenant
func (m *ModelProviderService) GetChatModel(ctx context.Context, tenantID, compositeModelName string) (*modelModule.ChatModel, error) {
- driver, modelName, apiConfig, _, err := m.ResolveModelConfig(ctx, tenantID, entity.ModelTypeChat, compositeModelName)
+ target, err := m.modelSolver().ResolveModelConfig(ctx, tenantID, entity.ModelTypeChat, compositeModelName)
if err != nil {
return nil, err
}
- return modelModule.NewChatModel(driver, &modelName, apiConfig), nil
+ return modelModule.NewChatModel(target.Driver, &target.ModelName, target.APIConfig), nil
}
// GetRerankModel returns a RerankModel wrapper for the given tenant
func (m *ModelProviderService) GetRerankModel(ctx context.Context, tenantID, compositeModelName string) (*modelModule.RerankModel, error) {
- driver, modelName, apiConfig, maxTokens, err := m.ResolveModelConfig(ctx, tenantID, entity.ModelTypeRerank, compositeModelName)
+ target, err := m.modelSolver().ResolveModelConfig(ctx, tenantID, entity.ModelTypeRerank, compositeModelName)
if err != nil {
return nil, err
}
- return modelModule.NewRerankModel(driver, &modelName, apiConfig, maxTokens), nil
+ return modelModule.NewRerankModel(target.Driver, &target.ModelName, target.APIConfig, target.MaxTokens), nil
}
type AddModelRequest struct {
@@ -3510,189 +3510,6 @@ type AddModelRequest struct {
Extra map[string]interface{} `json:"extra"`
}
-func (m *ModelProviderService) GetTenantDefaultModelByType(ctx context.Context, tenantID string, modelType entity.ModelType) (modelModule.ModelDriver, string, *modelModule.APIConfig, int, error) {
- if modelType == entity.ModelTypeOCR {
- return nil, "", nil, 0, fmt.Errorf("OCR model name is required")
- }
-
- tenant, err := m.tenantDAO.GetByID(ctx, dao.DB, tenantID)
- if err != nil {
- return nil, "", nil, 0, fmt.Errorf("failed to get tenant: %s type %s: %w", tenantID, modelType, err)
- }
- modelName, modelID := defaultModelRefs(tenant, modelType)
- if modelID != "" {
- driver, resolvedName, apiConfig, maxTokens, idErr := m.GetModelConfigByID(ctx, tenantID, modelType, modelID)
- if idErr == nil {
- return driver, resolvedName, apiConfig, maxTokens, nil
- }
- common.Warn("GetTenantDefaultModelByType: model_id lookup failed, falling back to model name",
- zap.String("tenantID", tenantID),
- zap.String("modelID", modelID),
- zap.Error(idErr))
- }
- if modelName == "" {
- return nil, "", nil, 0, fmt.Errorf("no default %s model is set", modelType)
- }
-
- return m.ResolveModelConfig(ctx, tenantID, modelType, modelName)
-}
-
-// GetTenantDefaultModelRef returns the composite model reference (the
-// "<model>@<instance>@<provider>" form stored on the tenant, e.g.
-// "MiniMax-M3@mm@MiniMax") that callers pass on to model config resolution.
-// Unlike GetTenantDefaultModelByType — which resolves the driver/API config and
-// returns a bare model name — this returns the reference verbatim so it can be
-// used as an llmID for a later ResolveModelConfig/Chat round-trip.
-func (m *ModelProviderService) GetTenantDefaultModelRef(ctx context.Context, tenantID string, modelType entity.ModelType) (string, error) {
- tenant, err := m.tenantDAO.GetByID(ctx, dao.DB, tenantID)
- if err != nil {
- return "", fmt.Errorf("failed to get tenant: %s type %s: %w", tenantID, modelType, err)
- }
- modelName, _ := defaultModelRefs(tenant, modelType)
- if strings.TrimSpace(modelName) == "" {
- return "", fmt.Errorf("no default %s model is set", modelType)
- }
- return modelName, nil
-}
-
-// GetModelConfigByID returns model driver and API config for a tenant_model row by its ID.
-func (m *ModelProviderService) GetModelConfigByID(ctx context.Context, userID string, modelType entity.ModelType, modelID string) (modelModule.ModelDriver, string, *modelModule.APIConfig, int, error) {
- common.Debug("GetModelConfigByID",
- zap.String("userID", userID),
- zap.String("modelType", modelType.String()),
- zap.String("modelID", modelID))
-
- modelEntity, err := m.modelDAO.GetByID(ctx, dao.DB, modelID)
- if err != nil {
- if errors.Is(err, gorm.ErrRecordNotFound) {
- return nil, "", nil, 0, fmt.Errorf("%w: tenant model id=%s not found", errModelConfigUnavailable, modelID)
- }
- return nil, "", nil, 0, err
- }
- if modelEntity.Status != "active" {
- return nil, "", nil, 0, fmt.Errorf("%w: tenant model id=%s is disabled", errModelConfigUnavailable, modelID)
- }
- if !entity.ModelType(modelEntity.ModelType).Has(modelType) {
- return nil, "", nil, 0, fmt.Errorf("%w: tenant model id=%s cannot be used as %s model", errModelConfigUnavailable, modelID, modelType.String())
- }
-
- providerEntity, err := m.modelProviderDAO.GetByID(ctx, dao.DB, modelEntity.ProviderID)
- if err != nil {
- if errors.Is(err, gorm.ErrRecordNotFound) {
- return nil, "", nil, 0, fmt.Errorf("%w: provider id=%s not found for model id=%s", errModelConfigUnavailable, modelEntity.ProviderID, modelID)
- }
- return nil, "", nil, 0, err
- }
- if providerEntity == nil {
- return nil, "", nil, 0, fmt.Errorf("%w: provider id=%s not found for model id=%s", errModelConfigUnavailable, modelEntity.ProviderID, modelID)
- }
-
- allowed, accessErr := m.tenantCanReachProviderTenant(ctx, userID, providerEntity.TenantID)
-
- if accessErr != nil {
- return nil, "", nil, 0, accessErr
- }
- if !allowed {
- return nil, "", nil, 0, fmt.Errorf(
- "%w: tenant %s has no access to provider owned by tenant %s",
- errModelConfigUnavailable,
- userID,
- providerEntity.TenantID,
- )
- }
-
- instanceEntity, err := m.modelInstanceDAO.GetByID(ctx, dao.DB, modelEntity.InstanceID)
- if err != nil {
- if errors.Is(err, gorm.ErrRecordNotFound) {
- return nil, "", nil, 0, fmt.Errorf("%w: instance id=%s not found for model id=%s", errModelConfigUnavailable, modelEntity.InstanceID, modelID)
- }
- return nil, "", nil, 0, err
- }
-
- apiKey := instanceEntity.APIKey
- extra, err := decodeModelInstanceExtra(instanceEntity.Extra)
- if err != nil {
- return nil, "", nil, 0, fmt.Errorf("%w: decode model instance configuration: %v", errModelConfigUnavailable, err)
- }
- region := extra.Region
- baseURL := extra.BaseURL
-
- providerInfo := dao.GetModelProviderManager().FindProvider(providerEntity.ProviderName)
- if providerInfo == nil {
- return nil, "", nil, 0, fmt.Errorf("%w: provider %q driver not found", errModelConfigUnavailable, providerEntity.ProviderName)
- }
- modelDriver, err := newModelDriverForBaseURL(providerInfo.ModelDriver, providerEntity.ProviderName, region, baseURL)
- if err != nil {
- return nil, "", nil, 0, fmt.Errorf("%w: create model driver: %v", errModelConfigUnavailable, err)
- }
-
- maxTokens := 0
- if mi, _ := dao.GetModelProviderManager().GetModelByName(providerEntity.ProviderName, modelEntity.ModelName); mi != nil {
- maxTokens = maxTokensFromModelInfo(mi, modelType)
- }
- maxTokens, err = maxTokensFromTenantModelExtra(modelEntity, maxTokens)
- if err != nil {
- return nil, "", nil, 0, fmt.Errorf("%w: read model limits: %v", errModelConfigUnavailable, err)
- }
-
- apiConfig := &modelModule.APIConfig{ApiKey: &apiKey, Region: &region, BaseURL: &baseURL}
- return modelDriver, modelEntity.ModelName, apiConfig, maxTokens, nil
-}
-
-func defaultModelRefs(tenant *entity.Tenant, modelType entity.ModelType) (string, string) {
- if tenant == nil {
- return "", ""
- }
- switch modelType {
- case entity.ModelTypeChat:
- return tenant.LLMID, ptrStringValue(tenant.TenantLLMID)
- case entity.ModelTypeEmbedding:
- return tenant.EmbdID, ptrStringValue(tenant.TenantEmbdID)
- case entity.ModelTypeRerank:
- return tenant.RerankID, ptrStringValue(tenant.TenantRerankID)
- case entity.ModelTypeSpeech2Text:
- return tenant.ASRID, ptrStringValue(tenant.TenantASRID)
- case entity.ModelTypeImage2Text:
- return tenant.Img2TxtID, ptrStringValue(tenant.TenantImg2TxtID)
- case entity.ModelTypeTTS:
- return ptrStringValue(tenant.TTSID), ptrStringValue(tenant.TenantTTSID)
- case entity.ModelTypeOCR:
- return ptrStringValue(tenant.OCRID), ptrStringValue(tenant.TenantOCRID)
- default:
- return "", ""
- }
-}
-
-func (m *ModelProviderService) ResolveModelConfig(ctx context.Context, tenantID string, modelType entity.ModelType, modelRef string) (modelModule.ModelDriver, string, *modelModule.APIConfig, int, error) {
- if strings.TrimSpace(modelRef) == "" {
- return nil, "", nil, 0, fmt.Errorf("%w: model ref is required", errModelConfigUnavailable)
- }
- if _, err := m.modelDAO.GetByID(ctx, dao.DB, modelRef); err == nil {
- return m.GetModelConfigByID(ctx, tenantID, modelType, modelRef)
- } else if !errors.Is(err, gorm.ErrRecordNotFound) {
- return nil, "", nil, 0, err
- }
- return m.GetModelConfigFromProviderInstance(ctx, tenantID, modelType, modelRef)
-}
-
-// ResolveModelContextLength returns the chat model's effective context window
-// (context_length) in tokens, or 0 when unknown. context_length is the total
-// context window and max_output is the generation cap; the
-// knowledge_compiler prompt-budget logic needs the context window, not the
-// output cap. modelRef accepts either a tenant model UUID or a
-// "model@instance@provider" composite name.
-//
-// The resolution is delegated to dao.ResolveModelContentLength so every
-// consumer shares one path: a tenant-configured "max_tokens" override in the
-// tenant_model.extra wins, otherwise the provider catalog's context_length is
-// used (D22/D23).
-func (m *ModelProviderService) ResolveModelContextLength(ctx context.Context, tenantID string, modelRef string) (int, error) {
- if strings.TrimSpace(modelRef) == "" {
- return 0, fmt.Errorf("model ref is required")
- }
- return dao.ResolveModelContentLength(ctx, dao.DB, tenantID, modelRef, "", ""), nil
-}
-
// ResolveModelToolSupport reports whether the resolved chat model supports
// function calling (tool calls). It mirrors Python dialog_service.rag_agent's
// `if not getattr(chat_mdl, "is_tools", False)` gate: a model without tool
@@ -3860,149 +3677,6 @@ func catalogToolSupport(providerName, modelName string) bool {
return mi.Tools.Support
}
-func (m *ModelProviderService) ResolveModelID(ctx context.Context, tenantID string, modelType entity.ModelType, modelName string) (string, error) {
- if modelObj, err := m.modelDAO.GetByID(ctx, dao.DB, modelName); err == nil {
- if modelObj.Status != "active" {
- return "", fmt.Errorf("tenant model id=%s is disabled", modelName)
- }
- if !entity.ModelType(modelObj.ModelType).Has(modelType) {
- return "", fmt.Errorf("tenant model id=%s cannot be used as %s model", modelName, modelType.String())
- }
- if _, _, _, _, err = m.GetModelConfigByID(ctx, tenantID, modelType, modelName); err != nil {
- return "", err
- }
- return modelObj.ID, nil
- } else if !errors.Is(err, gorm.ErrRecordNotFound) {
- return "", err
- }
-
- pureModelName, instanceName, providerName, err := parseModelName(modelName)
- if err != nil {
- return "", err
- }
-
- // Builtin provider: Builtin models (e.g. local TEI embeddings) have no
- // tenant_model_instance records, so there is no tenant-scoped model ID to
- // resolve. Downstream resolution (ResolveModelConfig / getModelConfig)
- // falls through to parseModelName → Builtin routing, which already works.
- if providerName == "Builtin" && modelType == entity.ModelTypeEmbedding {
- if builtinDriver := modelModule.GetBuiltinEmbeddingModel(pureModelName); builtinDriver == nil {
- return "", fmt.Errorf("builtin embedding model %q not found", pureModelName)
- }
- return "", nil
- }
-
- provider, err := m.modelProviderDAO.GetByTenantIDAndProviderName(ctx, dao.DB, tenantID, providerName)
- if err != nil {
- return "", fmt.Errorf("provider %q lookup failed: %w", providerName, err)
- }
- if provider == nil {
- return "", fmt.Errorf("provider %q not found for model %q", providerName, modelName)
- }
-
- instance, err := m.modelInstanceDAO.GetByProviderIDAndInstanceName(ctx, dao.DB, provider.ID, instanceName)
- if err != nil {
- return "", fmt.Errorf("instance %q lookup failed: %w", instanceName, err)
- }
- if instance == nil {
- return "", fmt.Errorf("instance %q not found for model %q", instanceName, modelName)
- }
-
- modelObj, err := m.modelDAO.GetByProviderIDAndInstanceIDAndModelTypeAndModelName(ctx, dao.DB, provider.ID, instance.ID, int(modelType), pureModelName)
- if err != nil {
- if errors.Is(err, gorm.ErrRecordNotFound) {
- return "", fmt.Errorf("model %q not found for model type %s", modelName, modelType.String())
- }
- return "", err
- }
- if modelObj.Status != "active" {
- return "", fmt.Errorf("model %q is disabled", modelName)
- }
- return modelObj.ID, nil
-}
-
-func (m *ModelProviderService) ResolveModelType(ctx context.Context, tenantID, modelRef string) ([]entity.ModelType, error) {
- modelObj, err := m.modelDAO.GetByID(ctx, dao.DB, modelRef)
- if err == nil {
- if modelObj.Status != "active" {
- return nil, fmt.Errorf("tenant model id=%s is disabled", modelRef)
- }
- return []entity.ModelType{entity.ModelType(modelObj.ModelType)}, nil
- }
- if !errors.Is(err, gorm.ErrRecordNotFound) {
- return nil, err
- }
- return m.GetModelTypeByName(ctx, tenantID, modelRef)
-}
-
-// GetModelTypeByName returns the list of model types the given model is enrolled as.
-func (m *ModelProviderService) GetModelTypeByName(ctx context.Context, tenantID, modelName string) ([]entity.ModelType, error) {
- common.Debug("GetModelTypeByName",
- zap.String("tenantID", tenantID),
- zap.String("modelName", modelName))
-
- pureModelName, instanceName, providerName, err := parseModelName(modelName)
- if err != nil {
- return nil, err
- }
-
- // Direct provider lookup
- provider, provErr := m.modelProviderDAO.GetByTenantIDAndProviderName(ctx, dao.DB, tenantID, providerName)
- if provErr != nil {
- return nil, fmt.Errorf("provider %q lookup failed: %w", providerName, provErr)
- }
- if provider == nil {
- return nil, fmt.Errorf("provider %q not found for model %q", providerName, modelName)
- }
-
- // Direct instance lookup
- instance, instErr := m.modelInstanceDAO.GetByProviderIDAndInstanceName(ctx, dao.DB, provider.ID, instanceName)
- if instErr != nil {
- return nil, fmt.Errorf("instance %q lookup failed: %w", instanceName, instErr)
- }
- if instance == nil {
- return nil, fmt.Errorf("instance %q not found for model %q", instanceName, modelName)
- }
-
- // Direct model lookup
- modelObjs, modelErr := m.modelDAO.GetModelsByProviderIDAndInstanceIDAndModelName(ctx, dao.DB, provider.ID, instance.ID, pureModelName)
- if modelErr == nil && len(modelObjs) > 0 {
- types := make([]entity.ModelType, 0, len(modelObjs))
- for _, obj := range modelObjs {
- types = append(types, entity.ModelType(obj.ModelType))
- }
- return types, nil
- }
-
- // Fallback: factory LLM catalog
- var extra map[string]string
- _ = json.Unmarshal([]byte(instance.Extra), &extra)
- region := extra["region"]
-
- targetFactoryName := providerName
- if region == "intl" && strings.EqualFold(providerName, "siliconflow") {
- targetFactoryName = "siliconflow_intl"
- }
- // Use the case-insensitive FindProvider / findModel helpers. The Go's
- // conf/models/*.json files now use the same names as the Python's
- // conf/llm_factories.json (e.g. "SILICONFLOW"); but a strict
- // `==` here would still fail for any case mismatch. The rest of the Go codebase
- // uses these helpers too.
- targetProvider := dao.GetModelProviderManager().FindProvider(targetFactoryName)
- if targetProvider == nil {
- return nil, fmt.Errorf("model provider config not found: %s", providerName)
- }
- for i := range targetProvider.Models {
- if strings.EqualFold(targetProvider.Models[i].Name, pureModelName) {
- if len(targetProvider.Models[i].ModelTypes) == 0 {
- return nil, fmt.Errorf("model %q has no model_types in factory catalog", pureModelName)
- }
- return []entity.ModelType{entity.ModelTypeFromString(targetProvider.Models[i].ModelTypes[0])}, nil
- }
- }
- return nil, fmt.Errorf("model %q not found for model %q", pureModelName, modelName)
-}
-
type AddCustomModelRequest struct {
ProviderName string `json:"provider_name"`
InstanceName string `json:"instance_name"`
@@ -4129,315 +3803,6 @@ func (m *ModelProviderService) AddModel(ctx context.Context, request *AddModelRe
return common.CodeSuccess, nil
}
-// GetModelConfigFromProviderInstance get model config from provider instance
-// modelName@instance@provider or
-// "model@provider" — the provider is required and is looked up directly via
-// tenant_model_provider. For 2-part names the instance defaults to "default".
-// If the model is enrolled in tenant_model, that row is used (and INACTIVE rows
-// raise). Otherwise, the factory's LLM catalog is consulted, with
-// region=intl + siliconflow redirected to the siliconflow_intl factory.
-func (m *ModelProviderService) GetModelConfigFromProviderInstance(ctx context.Context, tenantID string, modelType entity.ModelType, modelName string) (modelModule.ModelDriver, string, *modelModule.APIConfig, int, error) {
- common.Debug("GetModelConfigFromProviderInstance",
- zap.String("tenantID", tenantID),
- zap.String("modelName", modelName),
- zap.String("modelType", modelType.String()))
-
- // TEI builtin embedding short-circuit
- if modelType == entity.ModelTypeEmbedding && strings.Contains(common.GetEnv(common.EnvComposeProfiles), "tei-") {
- teiModel := common.GetEnv(common.EnvTEIModel)
- teiBaseURL := common.GetEnv(common.EnvTEIBaseURL)
-
- // First try exact match: handles bare model IDs like "model@q8_0"
- // where '@' is part of the model name itself.
- if modelName == teiModel {
- builtinDriver := modelModule.GetBuiltinEmbeddingModel(modelName)
- if builtinDriver == nil {
- return nil, "", nil, 0, fmt.Errorf("%w: builtin (TEI) embedding model %q not found", errModelConfigUnavailable, modelName)
- }
- apiConfig := &modelModule.APIConfig{ApiKey: nil, Region: nil, BaseURL: &teiBaseURL}
- return builtinDriver, modelName, apiConfig, 0, nil
- }
-
- // Then try right-anchored parsing for explicit "model@Builtin" or
- // "model@instance@Builtin" composite keys.
- teiPure, _, teiProvider := splitRightAnchoredModelName(modelName)
- if teiPure == teiModel && (teiProvider == "Builtin" || teiProvider == "") {
- builtinDriver := modelModule.GetBuiltinEmbeddingModel(teiPure)
- if builtinDriver == nil {
- return nil, "", nil, 0, fmt.Errorf("%w: builtin (TEI) embedding model %q not found", errModelConfigUnavailable, teiPure)
- }
- apiConfig := &modelModule.APIConfig{ApiKey: nil, Region: nil, BaseURL: &teiBaseURL}
- return builtinDriver, teiPure, apiConfig, 0, nil
- }
- }
-
- // Generic Builtin provider short-circuit. The tenant_model_provider /
- // tenant_model_instance tables don't have a row for "Builtin" because it's
- // a local service, not a tenant-enrolled provider — so the direct lookups
- // below would raise. Mirrors the private getModelConfig's Builtin branch.
- //
- // Gated on ModelTypeEmbedding because the Builtin driver here is the TEI
- // embedding endpoint; the underlying BuiltinModel's Chat/Rerank/AudioSpeech
- // /OCR methods all return hard "not supported" errors. A chat/rerank/etc.
- // request that names a Builtin provider must fall through to the standard
- // branch, which surfaces an accurate "provider not found" instead of
- // handing back an embedding-only driver.
- if modelType == entity.ModelTypeEmbedding {
- // The Builtin provider is a local service, not a tenant-enrolled
- // provider. Extract the model name by looking for the @Builtin
- // suffix explicitly so model names with embedded '@' characters
- // (e.g. `model@q8_0@Builtin` or bare `model@q8_0` without any
- // provider suffix) are handled correctly.
- var pureModelName string
- switch {
- case strings.HasSuffix(modelName, "@default@Builtin"):
- pureModelName = modelName[:len(modelName)-len("@default@Builtin")]
- case strings.HasSuffix(modelName, "@Builtin"):
- pureModelName = modelName[:len(modelName)-len("@Builtin")]
- default:
- pureModelName = ""
- }
- if pureModelName != "" {
- builtinDriver := modelModule.GetBuiltinEmbeddingModel(pureModelName)
- if builtinDriver == nil {
- return nil, "", nil, 0, fmt.Errorf("%w: builtin embedding model %q not found", errModelConfigUnavailable, pureModelName)
- }
- apiKey := ""
- region := ""
- apiConfig := &modelModule.APIConfig{ApiKey: &apiKey, Region: &region}
- maxTokens := 0
- if mi, _ := dao.GetModelProviderManager().GetModelByName("Builtin", pureModelName); mi != nil {
- maxTokens = maxTokensFromModelInfo(mi, modelType)
- }
- return builtinDriver, pureModelName, apiConfig, maxTokens, nil
- }
- }
-
- pureModelName, instanceName, providerName, err := parseModelName(modelName)
- if err != nil {
- return nil, "", nil, 0, fmt.Errorf("%w: %v", errModelConfigUnavailable, err)
- }
-
- // Direct provider lookup
- provider, provErr := m.modelProviderDAO.GetByTenantIDAndProviderName(ctx, dao.DB, tenantID, providerName)
- if provErr != nil {
- if errors.Is(provErr, gorm.ErrRecordNotFound) {
- return nil, "", nil, 0, fmt.Errorf("%w: provider %q lookup failed: %w", errModelConfigUnavailable, providerName, provErr)
- }
- return nil, "", nil, 0, fmt.Errorf("provider %q lookup failed: %w", providerName, provErr)
- }
- if provider == nil {
- return nil, "", nil, 0, fmt.Errorf("%w: provider %q not found for model %q", errModelConfigUnavailable, providerName, modelName)
- }
-
- // Direct instance lookup
- instance, instErr := m.modelInstanceDAO.GetByProviderIDAndInstanceName(ctx, dao.DB, provider.ID, instanceName)
- if instErr != nil {
- if errors.Is(instErr, gorm.ErrRecordNotFound) {
- return nil, "", nil, 0, fmt.Errorf("%w: instance %q lookup failed: %w", errModelConfigUnavailable, instanceName, instErr)
- }
- return nil, "", nil, 0, fmt.Errorf("instance %q lookup failed: %w", instanceName, instErr)
- }
- if instance == nil {
- return nil, "", nil, 0, fmt.Errorf("%w: instance %q not found for model %q", errModelConfigUnavailable, instanceName, modelName)
- }
-
- // Decode api_key and extra fields from the instance row
- apiKey := instance.APIKey
- extra, err := decodeModelInstanceExtra(instance.Extra)
- if err != nil {
- return nil, "", nil, 0, fmt.Errorf("%w: decode model instance configuration: %v", errModelConfigUnavailable, err)
- }
- region := extra.Region
- baseURL := extra.BaseURL
-
- // Direct model lookup
- modelObj, modelErr := m.modelDAO.GetByProviderIDAndInstanceIDAndModelTypeAndModelName(
- ctx, dao.DB, provider.ID, instance.ID, int(modelType), pureModelName,
- )
- switch {
- case modelErr == nil:
- // Happy path: tenant enrolled this model.
- // INACTIVE check
- if modelObj.Status == "inactive" {
- return nil, "", nil, 0, fmt.Errorf("%w: model %q is disabled", errModelConfigUnavailable, modelName)
- }
-
- providerInfo := dao.GetModelProviderManager().FindProvider(providerName)
- if providerInfo == nil {
- return nil, "", nil, 0, fmt.Errorf("%w: provider %q driver not found", errModelConfigUnavailable, providerName)
- }
- driver, driverErr := newModelDriverForBaseURL(providerInfo.ModelDriver, providerName, region, baseURL)
- if driverErr != nil {
- return nil, "", nil, 0, fmt.Errorf("%w: create model driver: %v", errModelConfigUnavailable, driverErr)
- }
- maxTokens := 0
- if mi, _ := dao.GetModelProviderManager().GetModelByName(providerName, pureModelName); mi != nil {
- maxTokens = maxTokensFromModelInfo(mi, modelType)
- }
- maxTokens, driverErr = maxTokensFromTenantModelExtra(modelObj, maxTokens)
- if driverErr != nil {
- return nil, "", nil, 0, fmt.Errorf("%w: read model limits: %v", errModelConfigUnavailable, driverErr)
- }
- apiConfig := &modelModule.APIConfig{ApiKey: &apiKey, Region: &region, BaseURL: &baseURL}
- return driver, modelObj.ModelName, apiConfig, maxTokens, nil
- case errors.Is(modelErr, gorm.ErrRecordNotFound):
- // Tenant hasn't enrolled this model. Fall through to the factory catalog.
- common.Debug("GetModelConfigFromProviderInstance: tenant has no row for model, falling back to factory catalog",
- zap.String("tenantID", tenantID),
- zap.String("providerName", providerName),
- zap.String("instanceName", instanceName),
- zap.String("modelType", modelType.String()),
- zap.String("modelName", pureModelName))
- default:
- // Surface unexpected DAO errors (e.g. transient DB failure) instead of
- // silently resolving from the factory catalog — that would mask disabled
- // or tenant-specific configurations.
- return nil, "", nil, 0, fmt.Errorf("model %q lookup failed: %w", modelName, modelErr)
- }
-
- // Fallback: factory LLM catalog
- targetFactoryName := providerName
- if region == "intl" && strings.EqualFold(providerName, "siliconflow") {
- targetFactoryName = "siliconflow_intl"
- }
- // Use the case-insensitive FindProvider / findModel helpers. The Go's
- // conf/models/*.json files now use the same names as the Python's
- // conf/llm_factories.json (e.g. "SILICONFLOW"); but a strict
- // `==` here would still fail for any case mismatch even though the Python passes
- // (its FACTORY_LLM_INFOS and the parsed provider_name happen to agree on
- // casing). The rest of the Go codebase uses these helpers too.
- targetProvider := dao.GetModelProviderManager().FindProvider(targetFactoryName)
- if targetProvider == nil {
- return nil, "", nil, 0, fmt.Errorf("%w: model provider config not found: %s", errModelConfigUnavailable, providerName)
- }
- var llmInfo *modelModule.Model
- for i := range targetProvider.Models {
- if strings.EqualFold(targetProvider.Models[i].Name, pureModelName) {
- llmInfo = targetProvider.Models[i]
- break
- }
- }
- if llmInfo == nil {
- return nil, "", nil, 0, fmt.Errorf("%w: model config not found: %s", errModelConfigUnavailable, modelName)
- }
- driver, driverErr := newModelDriverForBaseURL(targetProvider.ModelDriver, providerName, region, baseURL)
- if driverErr != nil {
- return nil, "", nil, 0, fmt.Errorf("%w: create model driver: %v", errModelConfigUnavailable, driverErr)
- }
- apiConfig := &modelModule.APIConfig{ApiKey: &apiKey, Region: &region, BaseURL: &baseURL}
- maxTokens := maxTokensFromModelInfo(llmInfo, modelType)
- return driver, llmInfo.Name, apiConfig, maxTokens, nil
-}
-
-// getModelConfig returns the model driver, model name, API config, and max tokens for a model
-func (m *ModelProviderService) getModelConfig(ctx context.Context, tenantID, compositeModelName string) (modelModule.ModelDriver, string, *modelModule.APIConfig, int, error) {
- modelName, instanceName, providerName, err := parseModelName(compositeModelName)
- if err != nil {
- return nil, "", nil, 0, err
- }
-
- // Check if provider exists (skip for Builtin provider)
- var providerID string
- if providerName != "Builtin" {
- var provider *entity.TenantModelProvider
- provider, err = m.modelProviderDAO.GetByTenantIDAndProviderName(ctx, dao.DB, tenantID, providerName)
- if err != nil {
- return nil, "", nil, 0, err
- }
- if provider == nil {
- return nil, "", nil, 0, fmt.Errorf("provider %s not found", providerName)
- }
- providerID = provider.ID
- } else {
- common.Debug("getModelConfig skipping provider lookup for Builtin")
- }
-
- // Get instance (skip for Builtin provider since it doesn't use tenant_model_instance)
- var instance *entity.TenantModelInstance
- if providerName != "Builtin" {
- instance, err = m.modelInstanceDAO.GetByProviderIDAndInstanceName(ctx, dao.DB, providerID, instanceName)
- if err != nil {
- return nil, "", nil, 0, err
- }
- if instance == nil {
- return nil, "", nil, 0, fmt.Errorf("instance %s not found for provider %s", instanceName, providerName)
- }
- common.Debug("getModelConfig instance found", zap.String("instanceName", instanceName))
- }
-
- // TODO: if provider name is Builtin, HOW TO?
-
- var extra map[string]string
- var region string
- var baseURL string
- if instance != nil {
- err = json.Unmarshal([]byte(instance.Extra), &extra)
- if err != nil {
- return nil, "", nil, 0, err
- }
- region = extra["region"]
- baseURL = extra["base_url"]
- }
-
- providerInfo := dao.GetModelProviderManager().FindProvider(providerName)
- if providerInfo == nil {
- if providerName != "Builtin" {
- return nil, "", nil, 0, fmt.Errorf("model provider config not found: %s", providerName)
- }
- }
-
- // Get model info to extract max_tokens
- modelInfo, err := dao.GetModelProviderManager().GetModelByName(providerName, modelName)
- maxTokens := 0
- if err == nil && modelInfo != nil {
- if modelInfo.MaxOutput == nil {
- maxTokens = 0
- } else {
- maxTokens = *modelInfo.MaxOutput
- }
- }
-
- // For Builtin provider, use empty APIKey and skip tenant_model lookup
- var apiKey string
- if providerName == "Builtin" {
- apiKey = ""
- // For Builtin, we need to get the ModelDriver from somewhere
- // Since Builtin models are handled locally, we return a special driver
- builtinDriver := modelModule.GetBuiltinEmbeddingModel(modelName)
- if builtinDriver == nil {
- return nil, "", nil, 0, fmt.Errorf("builtin embedding model %s not found", modelName)
- }
- apiConfig := &modelModule.APIConfig{ApiKey: &apiKey, Region: &region}
- return builtinDriver, modelName, apiConfig, maxTokens, nil
- }
-
- var modelRecord *entity.TenantModel
- modelRecord, err = m.modelDAO.GetModelByProviderIDAndInstanceIDAndModelName(ctx, dao.DB, providerID, instance.ID, modelName)
- if err != nil {
- if !errors.Is(err, gorm.ErrRecordNotFound) {
- return nil, "", nil, 0, fmt.Errorf("tenant model %q lookup failed: %w", modelName, err)
- }
- _, err = dao.GetModelProviderManager().GetModelByName(providerName, modelName)
- if err != nil {
- return nil, "", nil, 0, fmt.Errorf("provider %s model %s not found", providerName, modelName)
- }
- }
- maxTokens, err = maxTokensFromTenantModelExtra(modelRecord, maxTokens)
- if err != nil {
- return nil, "", nil, 0, err
- }
- apiKey = instance.APIKey
-
- driver, err := newModelDriverForBaseURL(providerInfo.ModelDriver, providerName, region, baseURL)
- if err != nil {
- return nil, "", nil, 0, err
- }
-
- apiConfig := &modelModule.APIConfig{ApiKey: &apiKey, Region: &region, BaseURL: &baseURL}
- return driver, modelName, apiConfig, maxTokens, nil
-}
-
// ListAllModels list all models
func (m *ModelProviderService) ListAllModels(pageIndex, pageSize int) ([]map[string]interface{}, error) {
models, err := dao.GetModelProviderManager().ListAllModels()
@@ -4463,7 +3828,7 @@ func (m *ModelProviderService) isImage2TextLLM(ctx context.Context, tenantID, ll
if m == nil || llmID == "" {
return false
}
- modelTypes, err := m.ResolveModelType(ctx, tenantID, llmID)
+ modelTypes, err := m.modelSolver().ResolveModelType(ctx, tenantID, llmID)
if err != nil {
return false
}
@@ -4474,18 +3839,3 @@ func (m *ModelProviderService) isImage2TextLLM(ctx context.Context, tenantID, ll
}
return false
}
-
-// GetChatModelConfig resolves the model configuration for a chat dialog.
-// If llmID is empty, falls back to the tenant's default chat model.
-// When the named LLM is registered as an image2text model, returns the
-// IMAGE2TEXT driver/config instead of CHAT.
-func (m *ModelProviderService) GetChatModelConfig(ctx context.Context, tenantID string, llmID string) (modelModule.ModelDriver, string, *modelModule.APIConfig, int, error) {
- if llmID == "" {
- return m.GetTenantDefaultModelByType(ctx, tenantID, entity.ModelTypeChat)
- }
- modelType := entity.ModelTypeChat
- if m.isImage2TextLLM(ctx, tenantID, llmID) {
- modelType = entity.ModelTypeImage2Text
- }
- return m.ResolveModelConfig(ctx, tenantID, modelType, llmID)
-}
diff --git a/internal/service/model_service_test.go b/internal/service/model_service_test.go
index 0e3a06bddc..9b5e754973 100644
--- a/internal/service/model_service_test.go
+++ b/internal/service/model_service_test.go
@@ -479,24 +479,24 @@ func TestModelProviderServiceAlterModelStatusByID(t *testing.T) {
}
}
-func TestModelProviderServiceGetModelConfigByID(t *testing.T) {
+func TestModelSolverResolveModelConfigByID(t *testing.T) {
db := setupModelProviderServiceTestDB(t)
useModelProviderServiceTestDB(t, db)
seedModelProviderServiceScope(t, db)
ctx := t.Context()
- driver, modelName, apiConfig, _, err := NewModelProviderService().GetModelConfigByID(ctx, "user-1", entity.ModelTypeChat, "model-1")
+ target, err := NewModelSolver().ResolveModelConfig(ctx, "user-1", entity.ModelTypeChat, "model-1")
if err != nil {
- t.Fatalf("GetModelConfigByID() error = %v", err)
+ t.Fatalf("ResolveModelConfig() error = %v", err)
}
- if driver == nil {
- t.Fatal("GetModelConfigByID() returned nil driver")
+ if target == nil || target.Driver == nil {
+ t.Fatal("ResolveModelConfig() returned nil target or driver")
}
- if modelName != "gpt-test" {
- t.Fatalf("modelName = %q, want %q", modelName, "gpt-test")
+ if target.ModelName != "gpt-test" {
+ t.Fatalf("modelName = %q, want %q", target.ModelName, "gpt-test")
}
- if apiConfig == nil || apiConfig.ApiKey == nil || *apiConfig.ApiKey != "sk-test" {
- t.Fatalf("apiConfig.ApiKey = %v, want %q", apiConfig.ApiKey, "sk-test")
+ if target.APIConfig == nil || target.APIConfig.ApiKey == nil || *target.APIConfig.ApiKey != "sk-test" {
+ t.Fatalf("apiConfig.ApiKey = %v, want %q", target.APIConfig.ApiKey, "sk-test")
}
}
@@ -516,7 +516,7 @@ func TestModelProviderServiceMissingProviderAndInstancePreserveLookupError(t *te
"unknown@default@OpenAI",
} {
t.Run(modelRef, func(t *testing.T) {
- _, _, _, _, err := NewModelProviderService().ResolveModelConfig(
+ _, err := NewModelSolver().ResolveModelConfig(
t.Context(), "tenant-1", entity.ModelTypeEmbedding, modelRef,
)
if !errors.Is(err, errModelConfigUnavailable) || !errors.Is(err, gorm.ErrRecordNotFound) {
@@ -536,21 +536,21 @@ func TestModelProviderServiceDecodesCompatibleInstanceExtra(t *testing.T) {
useModelProviderServiceTestDB(t, db)
seedModelProviderServiceScope(t, db)
- svc := NewModelProviderService()
+ solver := NewModelSolver()
resolvers := []struct {
name string
- resolve func() (modelModule.ModelDriver, string, *modelModule.APIConfig, int, error)
+ resolve func() (*ModelTarget, error)
}{
{
name: "model ID",
- resolve: func() (modelModule.ModelDriver, string, *modelModule.APIConfig, int, error) {
- return svc.GetModelConfigByID(t.Context(), "user-1", entity.ModelTypeChat, "model-1")
+ resolve: func() (*ModelTarget, error) {
+ return solver.ResolveModelConfig(t.Context(), "user-1", entity.ModelTypeChat, "model-1")
},
},
{
name: "provider instance",
- resolve: func() (modelModule.ModelDriver, string, *modelModule.APIConfig, int, error) {
- return svc.ResolveModelConfig(t.Context(), "tenant-1", entity.ModelTypeChat, "gpt-test@default@OpenAI")
+ resolve: func() (*ModelTarget, error) {
+ return solver.ResolveModelConfig(t.Context(), "tenant-1", entity.ModelTypeChat, "gpt-test@default@OpenAI")
},
},
}
@@ -578,10 +578,12 @@ func TestModelProviderServiceDecodesCompatibleInstanceExtra(t *testing.T) {
for _, resolver := range resolvers {
t.Run(resolver.name, func(t *testing.T) {
- driver, _, apiConfig, _, err := resolver.resolve()
+ target, err := resolver.resolve()
if err != nil {
t.Fatalf("resolve model config: %v", err)
}
+ driver := target.Driver
+ apiConfig := target.APIConfig
if driver == nil || apiConfig == nil || apiConfig.Region == nil || *apiConfig.Region != config.wantRegion || apiConfig.BaseURL == nil || *apiConfig.BaseURL != config.wantBaseURL {
t.Fatalf("resolved driver/config = %v/%+v, want region %q and base URL %q", driver, apiConfig, config.wantRegion, config.wantBaseURL)
}
@@ -606,106 +608,6 @@ func TestMaxTokensFromModelInfo(t *testing.T) {
}
}
-func TestModelProviderServiceResolveModelContextLength(t *testing.T) {
- db := setupModelProviderServiceTestDB(t)
- useModelProviderServiceTestDB(t, db)
- // Seed a tenant chat model that maps to a real factory-catalog model
- // (Anthropic / claude-opus-4-8 has context_length=1000000, max_output=128000).
- activeStatus := "1"
- rows := []interface{}{
- &entity.UserTenant{ID: "user-tenant-cl", UserID: "user-1", TenantID: "tenant-cl", Role: "owner", InvitedBy: "user-1", Status: &activeStatus},
- &entity.TenantModelProvider{ID: "provider-anthropic", TenantID: "tenant-cl", ProviderName: "Anthropic"},
- &entity.TenantModelInstance{ID: "instance-anthropic", ProviderID: "provider-anthropic", InstanceName: "default", APIKey: "sk-anthropic", Status: "active", Extra: "{}"},
- &entity.TenantModel{ID: "model-claude", ProviderID: "provider-anthropic", InstanceID: "instance-anthropic", ModelName: "claude-opus-4-8", ModelType: int(entity.ModelTypeChat), Status: "active"},
- }
- for _, row := range rows {
- if err := db.Create(row).Error; err != nil {
- t.Fatalf("failed to seed %T: %v", row, err)
- }
- }
-
- svc := NewModelProviderService()
- ctx := t.Context()
-
- // UUID path: resolves context_length (context window) from the factory
- // catalog, NOT max_output.
- got, err := svc.ResolveModelContextLength(ctx, "user-1", "model-claude")
- if err != nil {
- t.Fatalf("ResolveModelContextLength(uuid) error = %v", err)
- }
- if got != 1000000 {
- t.Fatalf("uuid context_length = %d, want 1000000 (must be the context window, not max_output=128000)", got)
- }
-
- // Composite "model@instance@provider" path resolves the same value.
- got2, err := svc.ResolveModelContextLength(ctx, "user-1", "claude-opus-4-8@default@Anthropic")
- if err != nil {
- t.Fatalf("ResolveModelContextLength(composite) error = %v", err)
- }
- if got2 != 1000000 {
- t.Fatalf("composite context_length = %d, want 1000000", got2)
- }
-}
-
-func TestModelProviderServiceResolveModelContextLengthUnknownModel(t *testing.T) {
- db := setupModelProviderServiceTestDB(t)
- useModelProviderServiceTestDB(t, db)
-
- // A model that does not exist in the factory catalog resolves to 0 so the
- // caller falls back to its default context length instead of failing.
- got, err := NewModelProviderService().ResolveModelContextLength(
- t.Context(), "user-1", "gpt-no-such-model@default@OpenAI")
- if err != nil {
- t.Fatalf("ResolveModelContextLength(unknown) error = %v", err)
- }
- if got != 0 {
- t.Fatalf("unknown model context_length = %d, want 0", got)
- }
-}
-
-// TestModelProviderServiceResolveModelContextLengthOverride verifies that the
-// tenant-configured "max_tokens" override in tenant_model.extra wins over the
-// catalog context_length through the service delegation. UUID resolution is
-// unscoped (globally unique); the composite path needs the real tenant id to
-// locate the tenant's provider/instance/model rows.
-func TestModelProviderServiceResolveModelContextLengthOverride(t *testing.T) {
- db := setupModelProviderServiceTestDB(t)
- useModelProviderServiceTestDB(t, db)
- activeStatus := "1"
- rows := []interface{}{
- &entity.UserTenant{ID: "user-tenant-cl", UserID: "user-1", TenantID: "tenant-cl", Role: "owner", InvitedBy: "user-1", Status: &activeStatus},
- &entity.TenantModelProvider{ID: "provider-anthropic", TenantID: "tenant-cl", ProviderName: "Anthropic"},
- &entity.TenantModelInstance{ID: "instance-anthropic", ProviderID: "provider-anthropic", InstanceName: "default", APIKey: "sk-anthropic", Status: "active", Extra: "{}"},
- &entity.TenantModel{ID: "model-claude", ProviderID: "provider-anthropic", InstanceID: "instance-anthropic", ModelName: "claude-opus-4-8", ModelType: int(entity.ModelTypeChat), Status: "active", Extra: `{"max_tokens": 4096}`},
- }
- for _, row := range rows {
- if err := db.Create(row).Error; err != nil {
- t.Fatalf("failed to seed %T: %v", row, err)
- }
- }
-
- svc := NewModelProviderService()
- ctx := t.Context()
-
- // UUID path: the 4096 override wins over catalog context_length 1000000.
- got, err := svc.ResolveModelContextLength(ctx, "user-1", "model-claude")
- if err != nil {
- t.Fatalf("ResolveModelContextLength(override uuid) error = %v", err)
- }
- if got != 4096 {
- t.Fatalf("uuid override context_length = %d, want 4096 (custom override, not catalog 1000000)", got)
- }
-
- // Composite path with the real tenant id honors the same override.
- got2, err := svc.ResolveModelContextLength(ctx, "tenant-cl", "claude-opus-4-8@default@Anthropic")
- if err != nil {
- t.Fatalf("ResolveModelContextLength(override composite) error = %v", err)
- }
- if got2 != 4096 {
- t.Fatalf("composite override context_length = %d, want 4096", got2)
- }
-}
-
func TestModelProviderServiceAlterModelRejectsInvalidStatus(t *testing.T) {
ctx := t.Context()
code, err := NewModelProviderService().AlterModel(ctx, "OpenAI", "default", "", "user-1", "model-1", map[string]interface{}{"status": "disabled"})
diff --git a/internal/service/model_service_tts_test.go b/internal/service/model_service_tts_test.go
index cbf0ce60ff..96eebc0c38 100644
--- a/internal/service/model_service_tts_test.go
+++ b/internal/service/model_service_tts_test.go
@@ -93,16 +93,15 @@ func TestAudioSpeech_PartialNamesRejected(t *testing.T) {
}
}
-// TestGetTenantDefaultModelByType_NilTTSPointer verifies the tenant
+// TestResolveDefaultModelConfig_NilTTSPointer verifies the tenant
// default-model resolution is nil-safe when the tts_id column is NULL
// (the reporter's configuration: every default set except TTS).
-func TestGetTenantDefaultModelByType_NilTTSPointer(t *testing.T) {
+func TestResolveDefaultModelConfig_NilTTSPointer(t *testing.T) {
testDB := setupServiceTestDB(t)
pushServiceDB(t, testDB)
insertTTSTestTenant(t, "tenant-2", nil)
- svc := NewModelProviderService()
- _, _, _, _, err := svc.GetTenantDefaultModelByType(t.Context(), "tenant-2", entity.ModelTypeTTS)
+ _, err := NewModelSolver().ResolveDefaultModelConfig(t.Context(), "tenant-2", entity.ModelTypeTTS)
if err == nil {
t.Fatal("expected error for nil tts_id, got nil")
}
diff --git a/internal/service/model_solver.go b/internal/service/model_solver.go
new file mode 100644
index 0000000000..454816add1
--- /dev/null
+++ b/internal/service/model_solver.go
@@ -0,0 +1,577 @@
+//
+// Copyright 2026 The InfiniFlow Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+package service
+
+import (
+ "context"
+ "errors"
+ "fmt"
+ "strings"
+
+ "gorm.io/gorm"
+
+ "ragflow/internal/common"
+ "ragflow/internal/dao"
+ "ragflow/internal/entity"
+ modelModule "ragflow/internal/entity/models"
+)
+
+// ModelTarget contains the resolved model configuration.
+// It is intentionally separate from the runtime ChatConfig, EmbeddingConfig,
+// and RerankConfig types. ModelTarget is selected by modelRef and carries the
+// provider-side objects needed to make a model call.
+type ModelTarget struct {
+ ModelID string
+ ModelName string
+ ModelType entity.ModelType
+ ProviderName string
+ InstanceName string
+ Driver modelModule.ModelDriver
+ APIConfig *modelModule.APIConfig
+ ModelInfo *modelModule.Model
+ ContextLength int
+ MaxTokens int
+}
+
+// ModelSolver is the new model-resolution entry point. The existing
+// ModelProviderService API remains untouched so callers can migrate to this
+// resolver independently.
+type ModelSolver struct {
+ service *ModelProviderService
+}
+
+// NewModelSolver creates a model resolver backed by the standard model
+// provider service.
+func NewModelSolver() *ModelSolver {
+ return &ModelSolver{service: NewModelProviderService()}
+}
+
+func (m *ModelProviderService) modelSolver() *ModelSolver {
+ return &ModelSolver{service: m}
+}
+
+// ResolveModelConfig resolves a model by modelRef for the requested modelType.
+// modelRef accepts either a tenant model ID or a composite reference in the
+// form "model@instance@provider" ("model@provider" also uses the default
+// instance).
+func (s *ModelSolver) ResolveModelConfig(ctx context.Context, tenantID string, modelType entity.ModelType, modelRef string) (*ModelTarget, error) {
+ modelRef = strings.TrimSpace(modelRef)
+ if modelRef == "" {
+ return nil, fmt.Errorf("%w: model ref is required", errModelConfigUnavailable)
+ }
+ if modelType == 0 {
+ return nil, fmt.Errorf("%w: model type is required", errModelConfigUnavailable)
+ }
+
+ model, err := s.resolveModel(ctx, tenantID, modelType, modelRef)
+ if err != nil {
+ return nil, err
+ }
+
+ maxTokens := model.maxTokens
+ if model.modelEntity != nil {
+ maxTokens = maxTokensFromModelInfo(model.modelInfo, modelType)
+ maxTokens, err = maxTokensFromTenantModelExtra(model.modelEntity, maxTokens)
+ if err != nil {
+ return nil, fmt.Errorf("%w: read model limits: %v", errModelConfigUnavailable, err)
+ }
+ }
+
+ contextLength := 0
+ if model.modelInfo != nil && model.modelInfo.ContextLength != nil {
+ contextLength = *model.modelInfo.ContextLength
+ }
+ if resolved := dao.ResolveModelContentLength(ctx, dao.DB, tenantID, modelRef, "", ""); resolved > 0 {
+ contextLength = resolved
+ }
+
+ return &ModelTarget{
+ ModelID: model.modelID,
+ ModelName: model.modelName,
+ ModelType: modelType,
+ ProviderName: model.providerEntity.ProviderName,
+ InstanceName: model.instanceName,
+ Driver: model.driver,
+ APIConfig: model.apiConfig,
+ ModelInfo: model.modelInfo,
+ ContextLength: contextLength,
+ MaxTokens: maxTokens,
+ }, nil
+}
+
+// ResolveDefaultModelConfig resolves the tenant's configured default model
+// for modelType. It first uses the tenant model ID when present and falls back
+// to the stored model reference if that ID is unavailable.
+func (s *ModelSolver) ResolveDefaultModelConfig(ctx context.Context, tenantID string, modelType entity.ModelType) (*ModelTarget, error) {
+ if s == nil || s.service == nil {
+ return nil, fmt.Errorf("%w: model solver is not initialized", errModelConfigUnavailable)
+ }
+ tenantID = strings.TrimSpace(tenantID)
+ if tenantID == "" {
+ return nil, fmt.Errorf("%w: tenant id is required", errModelConfigUnavailable)
+ }
+ if modelType == 0 {
+ return nil, fmt.Errorf("%w: model type is required", errModelConfigUnavailable)
+ }
+ if modelType == entity.ModelTypeOCR {
+ return nil, fmt.Errorf("OCR model name is required")
+ }
+ if s.service.tenantDAO == nil {
+ return nil, fmt.Errorf("%w: tenant service is not initialized", errModelConfigUnavailable)
+ }
+
+ tenant, err := s.service.tenantDAO.GetByID(ctx, dao.DB, tenantID)
+ if err != nil {
+ return nil, fmt.Errorf("failed to get tenant: %s type %s: %w", tenantID, modelType, err)
+ }
+ modelName, modelID := defaultModelRefs(tenant, modelType)
+ if modelID != "" {
+ if target, idErr := s.ResolveModelConfig(ctx, tenantID, modelType, modelID); idErr == nil {
+ return target, nil
+ }
+ }
+ if strings.TrimSpace(modelName) == "" {
+ return nil, fmt.Errorf("no default %s model is set", modelType)
+ }
+ return s.ResolveModelConfig(ctx, tenantID, modelType, modelName)
+}
+
+func defaultModelRefs(tenant *entity.Tenant, modelType entity.ModelType) (string, string) {
+ if tenant == nil {
+ return "", ""
+ }
+ switch modelType {
+ case entity.ModelTypeChat:
+ return tenant.LLMID, ptrStringValue(tenant.TenantLLMID)
+ case entity.ModelTypeEmbedding:
+ return tenant.EmbdID, ptrStringValue(tenant.TenantEmbdID)
+ case entity.ModelTypeRerank:
+ return tenant.RerankID, ptrStringValue(tenant.TenantRerankID)
+ case entity.ModelTypeSpeech2Text:
+ return tenant.ASRID, ptrStringValue(tenant.TenantASRID)
+ case entity.ModelTypeImage2Text:
+ return tenant.Img2TxtID, ptrStringValue(tenant.TenantImg2TxtID)
+ case entity.ModelTypeTTS:
+ return ptrStringValue(tenant.TTSID), ptrStringValue(tenant.TenantTTSID)
+ case entity.ModelTypeOCR:
+ return ptrStringValue(tenant.OCRID), ptrStringValue(tenant.TenantOCRID)
+ default:
+ return "", ""
+ }
+}
+
+// ResolveModelType returns every model category supported by modelRef. A
+// model may expose multiple categories, such as chat and vision.
+func (s *ModelSolver) ResolveModelType(ctx context.Context, tenantID, modelRef string) ([]entity.ModelType, error) {
+ modelRef = strings.TrimSpace(modelRef)
+ if modelRef == "" {
+ return nil, fmt.Errorf("%w: model ref is required", errModelConfigUnavailable)
+ }
+
+ model, err := s.lookupTenantModel(ctx, tenantID, modelRef)
+ if err == nil {
+ identity, identityErr := s.modelIdentity(ctx, tenantID, model, modelRef)
+ if identityErr != nil {
+ return nil, identityErr
+ }
+ return modelTypesFromBitmask(identity.modelType), nil
+ }
+ if !errors.Is(err, gorm.ErrRecordNotFound) {
+ return nil, err
+ }
+
+ modelType, err := s.resolveCompositeModelType(ctx, tenantID, modelRef)
+ if err != nil {
+ return nil, err
+ }
+ return modelTypesFromBitmask(modelType), nil
+}
+
+type modelIdentity struct {
+ modelEntity *entity.TenantModel
+ providerEntity *entity.TenantModelProvider
+ modelType entity.ModelType
+}
+
+type resolvedModel struct {
+ modelEntity *entity.TenantModel
+ providerEntity *entity.TenantModelProvider
+ modelInfo *modelModule.Model
+ modelType entity.ModelType
+ modelID string
+ modelName string
+ instanceName string
+ driver modelModule.ModelDriver
+ apiConfig *modelModule.APIConfig
+ maxTokens int
+}
+
+func (s *ModelSolver) lookupTenantModel(ctx context.Context, tenantID, modelRef string) (*entity.TenantModel, error) {
+ if s == nil || s.service == nil {
+ return nil, fmt.Errorf("%w: model solver is not initialized", errModelConfigUnavailable)
+ }
+ tenantID = strings.TrimSpace(tenantID)
+ if tenantID == "" {
+ return nil, fmt.Errorf("%w: tenant id is required", errModelConfigUnavailable)
+ }
+ if modelRef == "" {
+ return nil, fmt.Errorf("%w: model ref is required", errModelConfigUnavailable)
+ }
+ if s.service.modelDAO == nil {
+ return nil, fmt.Errorf("%w: model service is not initialized", errModelConfigUnavailable)
+ }
+
+ return s.service.modelDAO.GetByID(ctx, dao.DB, modelRef)
+}
+
+func (s *ModelSolver) modelIdentity(ctx context.Context, tenantID string, modelEntity *entity.TenantModel, modelRef string) (*modelIdentity, error) {
+ if modelEntity == nil {
+ return nil, fmt.Errorf("%w: tenant model %q not found", errModelConfigUnavailable, modelRef)
+ }
+ if modelEntity.Status != "active" {
+ return nil, fmt.Errorf("%w: tenant model %q is disabled", errModelConfigUnavailable, modelRef)
+ }
+
+ modelType := entity.ModelType(modelEntity.ModelType)
+ if modelType == 0 {
+ return nil, fmt.Errorf("%w: tenant model %q has no model type", errModelConfigUnavailable, modelRef)
+ }
+ if s.service.modelProviderDAO == nil || s.service.modelInstanceDAO == nil {
+ return nil, fmt.Errorf("%w: model service is not initialized", errModelConfigUnavailable)
+ }
+
+ providerEntity, err := s.service.modelProviderDAO.GetByID(ctx, dao.DB, modelEntity.ProviderID)
+ if err != nil {
+ if errors.Is(err, gorm.ErrRecordNotFound) {
+ return nil, fmt.Errorf("%w: provider id=%s not found for model %q", errModelConfigUnavailable, modelEntity.ProviderID, modelRef)
+ }
+ return nil, err
+ }
+ if providerEntity == nil {
+ return nil, fmt.Errorf("%w: provider id=%s not found for model %q", errModelConfigUnavailable, modelEntity.ProviderID, modelRef)
+ }
+
+ allowed, err := s.service.tenantCanReachProviderTenant(ctx, tenantID, providerEntity.TenantID)
+ if err != nil {
+ return nil, err
+ }
+ if !allowed {
+ return nil, fmt.Errorf(
+ "%w: tenant %s has no access to provider owned by tenant %s",
+ errModelConfigUnavailable,
+ tenantID,
+ providerEntity.TenantID,
+ )
+ }
+
+ return &modelIdentity{
+ modelEntity: modelEntity,
+ providerEntity: providerEntity,
+ modelType: modelType,
+ }, nil
+}
+
+func (s *ModelSolver) resolveModel(ctx context.Context, tenantID string, modelType entity.ModelType, modelRef string) (*resolvedModel, error) {
+ modelEntity, err := s.lookupTenantModel(ctx, tenantID, modelRef)
+ if err != nil {
+ if errors.Is(err, gorm.ErrRecordNotFound) {
+ return s.resolveCompositeModel(ctx, tenantID, modelType, modelRef)
+ }
+ return nil, err
+ }
+ identity, err := s.modelIdentity(ctx, tenantID, modelEntity, modelRef)
+ if err != nil {
+ return nil, err
+ }
+ if !identity.modelType.Has(modelType) {
+ return nil, fmt.Errorf("%w: tenant model %q cannot be used as %s model", errModelConfigUnavailable, modelRef, modelType.String())
+ }
+ return s.resolveTenantModel(ctx, tenantID, modelType, modelRef, identity)
+}
+
+func (s *ModelSolver) resolveTenantModel(ctx context.Context, tenantID string, modelType entity.ModelType, modelRef string, identity *modelIdentity) (*resolvedModel, error) {
+ modelEntity := identity.modelEntity
+ providerEntity := identity.providerEntity
+
+ instanceEntity, err := s.service.modelInstanceDAO.GetByID(ctx, dao.DB, modelEntity.InstanceID)
+ if err != nil {
+ if errors.Is(err, gorm.ErrRecordNotFound) {
+ return nil, fmt.Errorf("%w: instance id=%s not found for model %q", errModelConfigUnavailable, modelEntity.InstanceID, modelRef)
+ }
+ return nil, err
+ }
+ if instanceEntity == nil {
+ return nil, fmt.Errorf("%w: instance id=%s not found for model %q", errModelConfigUnavailable, modelEntity.InstanceID, modelRef)
+ }
+
+ providerInfo := dao.GetModelProviderManager().FindProvider(providerEntity.ProviderName)
+ if providerInfo == nil {
+ return nil, fmt.Errorf("%w: provider %q driver not found", errModelConfigUnavailable, providerEntity.ProviderName)
+ }
+
+ modelInfo, _ := dao.GetModelProviderManager().GetModelByName(providerEntity.ProviderName, modelEntity.ModelName)
+ if modelInfo != nil {
+ modelInfo, err = modelInfoWithTenantExtra(modelInfo, modelEntity)
+ if err != nil {
+ return nil, fmt.Errorf("%w: read model metadata: %v", errModelConfigUnavailable, err)
+ }
+ }
+
+ extra, err := decodeModelInstanceExtra(instanceEntity.Extra)
+ if err != nil {
+ return nil, fmt.Errorf("%w: decode model instance configuration: %v", errModelConfigUnavailable, err)
+ }
+ apiKey := instanceEntity.APIKey
+ region := extra.Region
+ baseURL := extra.BaseURL
+ driver, err := newModelDriverForBaseURL(providerInfo.ModelDriver, providerEntity.ProviderName, region, baseURL)
+ if err != nil {
+ return nil, fmt.Errorf("%w: create model driver: %v", errModelConfigUnavailable, err)
+ }
+
+ return &resolvedModel{
+ modelEntity: modelEntity,
+ providerEntity: providerEntity,
+ modelInfo: modelInfo,
+ modelType: modelType,
+ modelID: modelEntity.ID,
+ modelName: modelEntity.ModelName,
+ instanceName: instanceEntity.InstanceName,
+ driver: driver,
+ apiConfig: &modelModule.APIConfig{ApiKey: &apiKey, Region: &region, BaseURL: &baseURL},
+ }, nil
+}
+
+func (s *ModelSolver) resolveCompositeModel(ctx context.Context, tenantID string, modelType entity.ModelType, modelRef string) (*resolvedModel, error) {
+ availableTypes, err := s.resolveCompositeModelType(ctx, tenantID, modelRef)
+ if err != nil {
+ return nil, err
+ }
+ if !availableTypes.Has(modelType) {
+ return nil, fmt.Errorf("%w: model %q cannot be used as %s model", errModelConfigUnavailable, modelRef, modelType.String())
+ }
+ resolved, err := s.resolveProviderInstanceModel(ctx, tenantID, modelType, modelRef)
+ if err != nil {
+ return nil, err
+ }
+ return resolved, nil
+}
+
+func (s *ModelSolver) resolveProviderInstanceModel(ctx context.Context, tenantID string, modelType entity.ModelType, modelRef string) (*resolvedModel, error) {
+ // TEI builtin embedding short-circuit.
+ if modelType == entity.ModelTypeEmbedding && strings.Contains(common.GetEnv(common.EnvComposeProfiles), "tei-") {
+ teiModel := common.GetEnv(common.EnvTEIModel)
+ teiBaseURL := common.GetEnv(common.EnvTEIBaseURL)
+ if modelRef == teiModel {
+ driver := modelModule.GetBuiltinEmbeddingModel(modelRef)
+ if driver == nil {
+ return nil, fmt.Errorf("%w: builtin (TEI) embedding model %q not found", errModelConfigUnavailable, modelRef)
+ }
+ return &resolvedModel{providerEntity: &entity.TenantModelProvider{ProviderName: "Builtin"}, modelType: modelType, modelName: modelRef, driver: driver, apiConfig: &modelModule.APIConfig{BaseURL: &teiBaseURL}}, nil
+ }
+ teiPure, _, teiProvider := splitRightAnchoredModelName(modelRef)
+ if teiPure == teiModel && (teiProvider == "Builtin" || teiProvider == "") {
+ driver := modelModule.GetBuiltinEmbeddingModel(teiPure)
+ if driver == nil {
+ return nil, fmt.Errorf("%w: builtin (TEI) embedding model %q not found", errModelConfigUnavailable, teiPure)
+ }
+ return &resolvedModel{providerEntity: &entity.TenantModelProvider{ProviderName: "Builtin"}, modelType: modelType, modelName: teiPure, driver: driver, apiConfig: &modelModule.APIConfig{BaseURL: &teiBaseURL}}, nil
+ }
+ }
+
+ pureModelName, instanceName, providerName, err := parseModelName(modelRef)
+ if err != nil {
+ return nil, fmt.Errorf("%w: %v", errModelConfigUnavailable, err)
+ }
+ if modelType == entity.ModelTypeEmbedding {
+ var builtinName string
+ switch {
+ case strings.HasSuffix(modelRef, "@default@Builtin"):
+ builtinName = strings.TrimSuffix(modelRef, "@default@Builtin")
+ case strings.HasSuffix(modelRef, "@Builtin"):
+ builtinName = strings.TrimSuffix(modelRef, "@Builtin")
+ }
+ if builtinName != "" {
+ driver := modelModule.GetBuiltinEmbeddingModel(builtinName)
+ if driver == nil {
+ return nil, fmt.Errorf("%w: builtin embedding model %q not found", errModelConfigUnavailable, builtinName)
+ }
+ apiKey, region := "", ""
+ maxTokens := 0
+ modelInfo, _ := dao.GetModelProviderManager().GetModelByName("Builtin", builtinName)
+ if modelInfo != nil {
+ maxTokens = maxTokensFromModelInfo(modelInfo, modelType)
+ }
+ return &resolvedModel{providerEntity: &entity.TenantModelProvider{ProviderName: "Builtin"}, modelInfo: modelInfo, modelType: modelType, modelName: builtinName, driver: driver, apiConfig: &modelModule.APIConfig{ApiKey: &apiKey, Region: &region}, maxTokens: maxTokens}, nil
+ }
+ }
+
+ provider, err := s.service.modelProviderDAO.GetByTenantIDAndProviderName(ctx, dao.DB, tenantID, providerName)
+ if err != nil {
+ if errors.Is(err, gorm.ErrRecordNotFound) {
+ return nil, fmt.Errorf("%w: provider %q lookup failed: %w", errModelConfigUnavailable, providerName, err)
+ }
+ return nil, fmt.Errorf("provider %q lookup failed: %w", providerName, err)
+ }
+ if provider == nil {
+ return nil, fmt.Errorf("%w: provider %q not found for model %q", errModelConfigUnavailable, providerName, modelRef)
+ }
+ instance, err := s.service.modelInstanceDAO.GetByProviderIDAndInstanceName(ctx, dao.DB, provider.ID, instanceName)
+ if err != nil {
+ if errors.Is(err, gorm.ErrRecordNotFound) {
+ return nil, fmt.Errorf("%w: instance %q lookup failed: %w", errModelConfigUnavailable, instanceName, err)
+ }
+ return nil, fmt.Errorf("instance %q lookup failed: %w", instanceName, err)
+ }
+ if instance == nil {
+ return nil, fmt.Errorf("%w: instance %q not found for model %q", errModelConfigUnavailable, instanceName, modelRef)
+ }
+ extra, err := decodeModelInstanceExtra(instance.Extra)
+ if err != nil {
+ return nil, fmt.Errorf("%w: decode model instance configuration: %v", errModelConfigUnavailable, err)
+ }
+ region, baseURL, apiKey := extra.Region, extra.BaseURL, instance.APIKey
+ modelEntity, err := s.service.modelDAO.GetByProviderIDAndInstanceIDAndModelTypeAndModelName(ctx, dao.DB, provider.ID, instance.ID, int(modelType), pureModelName)
+ if err != nil && !errors.Is(err, gorm.ErrRecordNotFound) {
+ return nil, fmt.Errorf("model %q lookup failed: %w", modelRef, err)
+ }
+ providerInfo := dao.GetModelProviderManager().FindProvider(providerName)
+ if modelEntity != nil {
+ if modelEntity.Status == "inactive" {
+ return nil, fmt.Errorf("%w: model %q is disabled", errModelConfigUnavailable, modelRef)
+ }
+ if providerInfo == nil {
+ return nil, fmt.Errorf("%w: provider %q driver not found", errModelConfigUnavailable, providerName)
+ }
+ driver, driverErr := newModelDriverForBaseURL(providerInfo.ModelDriver, providerName, region, baseURL)
+ if driverErr != nil {
+ return nil, fmt.Errorf("%w: create model driver: %v", errModelConfigUnavailable, driverErr)
+ }
+ modelInfo, _ := dao.GetModelProviderManager().GetModelByName(providerName, pureModelName)
+ maxTokens := maxTokensFromModelInfo(modelInfo, modelType)
+ maxTokens, err = maxTokensFromTenantModelExtra(modelEntity, maxTokens)
+ if err != nil {
+ return nil, fmt.Errorf("%w: read model limits: %v", errModelConfigUnavailable, err)
+ }
+ return &resolvedModel{modelEntity: modelEntity, providerEntity: provider, modelInfo: modelInfo, modelType: modelType, modelID: modelEntity.ID, modelName: modelEntity.ModelName, instanceName: instanceName, driver: driver, apiConfig: &modelModule.APIConfig{ApiKey: &apiKey, Region: &region, BaseURL: &baseURL}, maxTokens: maxTokens}, nil
+ }
+ if providerInfo == nil {
+ return nil, fmt.Errorf("%w: model provider config not found: %s", errModelConfigUnavailable, providerName)
+ }
+ targetFactoryName := providerName
+ if region == "intl" && strings.EqualFold(providerName, "siliconflow") {
+ targetFactoryName = "siliconflow_intl"
+ }
+ targetProvider := dao.GetModelProviderManager().FindProvider(targetFactoryName)
+ if targetProvider == nil {
+ return nil, fmt.Errorf("%w: model provider config not found: %s", errModelConfigUnavailable, providerName)
+ }
+ var modelInfo *modelModule.Model
+ for _, candidate := range targetProvider.Models {
+ if strings.EqualFold(candidate.Name, pureModelName) {
+ modelInfo = candidate
+ break
+ }
+ }
+ if modelInfo == nil {
+ return nil, fmt.Errorf("%w: model config not found: %s", errModelConfigUnavailable, modelRef)
+ }
+ driver, err := newModelDriverForBaseURL(targetProvider.ModelDriver, providerName, region, baseURL)
+ if err != nil {
+ return nil, fmt.Errorf("%w: create model driver: %v", errModelConfigUnavailable, err)
+ }
+ return &resolvedModel{providerEntity: provider, modelInfo: modelInfo, modelType: modelType, modelName: modelInfo.Name, instanceName: instanceName, driver: driver, apiConfig: &modelModule.APIConfig{ApiKey: &apiKey, Region: &region, BaseURL: &baseURL}, maxTokens: maxTokensFromModelInfo(modelInfo, modelType)}, nil
+}
+
+func (s *ModelSolver) resolveCompositeModelType(ctx context.Context, tenantID, modelRef string) (entity.ModelType, error) {
+ pureModelName, instanceName, providerName, err := parseModelName(modelRef)
+ if err != nil {
+ return 0, fmt.Errorf("%w: %v", errModelConfigUnavailable, err)
+ }
+
+ if strings.EqualFold(providerName, "Builtin") {
+ if modelModule.GetBuiltinEmbeddingModel(pureModelName) == nil {
+ return 0, fmt.Errorf("%w: builtin model %q not found", errModelConfigUnavailable, pureModelName)
+ }
+ return entity.ModelTypeEmbedding, nil
+ }
+ if s == nil || s.service == nil || s.service.modelProviderDAO == nil || s.service.modelInstanceDAO == nil || s.service.modelDAO == nil {
+ return 0, fmt.Errorf("%w: model service is not initialized", errModelConfigUnavailable)
+ }
+
+ provider, err := s.service.modelProviderDAO.GetByTenantIDAndProviderName(ctx, dao.DB, tenantID, providerName)
+ if err != nil {
+ return 0, fmt.Errorf("%w: provider %q lookup failed: %w", errModelConfigUnavailable, providerName, err)
+ }
+ if provider == nil {
+ return 0, fmt.Errorf("%w: provider %q not found for model %q", errModelConfigUnavailable, providerName, modelRef)
+ }
+ instance, err := s.service.modelInstanceDAO.GetByProviderIDAndInstanceName(ctx, dao.DB, provider.ID, instanceName)
+ if err != nil {
+ return 0, fmt.Errorf("%w: instance %q lookup failed: %w", errModelConfigUnavailable, instanceName, err)
+ }
+ if instance == nil {
+ return 0, fmt.Errorf("%w: instance %q not found for model %q", errModelConfigUnavailable, instanceName, modelRef)
+ }
+
+ models, err := s.service.modelDAO.GetModelsByProviderIDAndInstanceIDAndModelName(ctx, dao.DB, provider.ID, instance.ID, pureModelName)
+ if err != nil {
+ return 0, fmt.Errorf("%w: model %q lookup failed: %v", errModelConfigUnavailable, modelRef, err)
+ }
+ var modelType entity.ModelType
+ for _, model := range models {
+ if model != nil && model.Status == "active" {
+ modelType |= entity.ModelType(model.ModelType)
+ }
+ }
+ if modelType != 0 {
+ return modelType, nil
+ }
+
+ providerInfo := dao.GetModelProviderManager().FindProvider(providerName)
+ if providerInfo == nil {
+ return 0, fmt.Errorf("%w: model provider config not found: %s", errModelConfigUnavailable, providerName)
+ }
+ for _, model := range providerInfo.Models {
+ if model != nil && strings.EqualFold(model.Name, pureModelName) {
+ modelType = entity.ModelTypeFromStrings(model.ModelTypes)
+ if modelType != 0 {
+ return modelType, nil
+ }
+ break
+ }
+ }
+ return 0, fmt.Errorf("%w: model %q not found for provider %q", errModelConfigUnavailable, pureModelName, providerName)
+}
+
+func modelTypesFromBitmask(modelType entity.ModelType) []entity.ModelType {
+ modelTypes := make([]entity.ModelType, 0, 7)
+ for _, candidate := range []entity.ModelType{
+ entity.ModelTypeChat,
+ entity.ModelTypeEmbedding,
+ entity.ModelTypeSpeech2Text,
+ entity.ModelTypeImage2Text,
+ entity.ModelTypeRerank,
+ entity.ModelTypeTTS,
+ entity.ModelTypeOCR,
+ } {
+ if modelType.Has(candidate) {
+ modelTypes = append(modelTypes, candidate)
+ }
+ }
+ return modelTypes
+}
diff --git a/internal/service/nav_embedder.go b/internal/service/nav_embedder.go
index f0877a0f32..16ab21de09 100644
--- a/internal/service/nav_embedder.go
+++ b/internal/service/nav_embedder.go
@@ -60,22 +60,19 @@ func (e *NavEmbedder) encode(ctx context.Context, tenantID string, texts []strin
return nil, fmt.Errorf("datasetnav: embedding model service not initialized")
}
name := e.embdModelName
+ var model *modelModule.EmbeddingModel
if name == "" {
- // Resolve the tenant's default embedding model composite reference
- // ("<model>@<instance>@<provider>") — NOT the tenant id. Passing the
- // tenant id as the model ref makes ResolveModelConfig parse it as a
- // "model@provider" key, which fails with "provider name missing in model
- // name: <tenant_id>". Mirrors knowledge_compiler_wiring.go's chat-model
- // default resolution.
- ref, err := e.modelSvc.GetTenantDefaultModelRef(ctx, tenantID, entity.ModelTypeEmbedding)
+ target, err := e.modelSvc.modelSolver().ResolveDefaultModelConfig(ctx, tenantID, entity.ModelTypeEmbedding)
+ if err != nil {
+ return nil, fmt.Errorf("datasetnav: resolve embedding model for tenant %s: %w", tenantID, err)
+ }
+ model = modelModule.NewEmbeddingModel(target.Driver, &target.ModelName, target.APIConfig, target.MaxTokens)
+ } else {
+ var err error
+ model, err = e.modelSvc.GetEmbeddingModel(ctx, tenantID, name)
if err != nil {
return nil, fmt.Errorf("datasetnav: resolve embedding model for tenant %s: %w", tenantID, err)
}
- name = ref
- }
- model, err := e.modelSvc.GetEmbeddingModel(ctx, tenantID, name)
- if err != nil {
- return nil, fmt.Errorf("datasetnav: resolve embedding model for tenant %s: %w", tenantID, err)
}
nonEmpty := make([]string, 0, len(texts))
for _, t := range texts {
diff --git a/internal/service/openai_chat.go b/internal/service/openai_chat.go
index 61f5d57b7a..8703e6709d 100644
--- a/internal/service/openai_chat.go
+++ b/internal/service/openai_chat.go
@@ -249,7 +249,11 @@ func (s *OpenAIChatService) OpenAIChatCompletions(c *gin.Context, userID, chatID
}
}
if req.Model != "model" {
- if _, _, _, _, mErr := s.pipeline.ModelProviderSvc.GetChatModelConfig(ctx, dialog.TenantID, resolvedModel); mErr != nil {
+ modelType := entity.ModelTypeChat
+ if s.pipeline.ModelProviderSvc.isImage2TextLLM(ctx, dialog.TenantID, resolvedModel) {
+ modelType = entity.ModelTypeImage2Text
+ }
+ if _, mErr := s.pipeline.ModelProviderSvc.modelSolver().ResolveModelConfig(ctx, dialog.TenantID, modelType, resolvedModel); mErr != nil {
s.writeArgError(c, fmt.Sprintf("`llm_id` %s doesn't exist", req.Model))
return
}