mirror of
https://github.com/hanzoai/ai.git
synced 2026-11-20 14:13:23 +00:00
hanzoai/ai#71 healed the default-embed provider in object.InitDb, but the fused cloud binary reads the persisted DB provider and the RAG embed path resolves it through getEmbeddingProviderFromName (via the default store), which did NOT go through the seed heal — so /v1/rag/embed still hit api.openai.com and hung ~180s, and the Qdrant collection was still never created (verified live on v1.786.85). Add forceGatewayEmbedder at the embedder-resolution point (getEmbeddingProviderFromName, the ONE path resolveEmbedder uses for ingest AND query): when a gateway base is configured (CLOUD_AI_BASE_URL) and the provider is a known-broken default (empty or api.openai.com ProviderUrl), redirect it in place to the gateway (text-embedding-qwen3, key resolved env-first from CLOUD_AI_API_KEY). A healthy custom embedder is never touched; standalone ai with no gateway env is unaffected. Unit tests pin the redirect + the untouched-custom + key-resolution cases.
210 lines
7.8 KiB
Go
210 lines
7.8 KiB
Go
// Copyright 2023-2025 Hanzo AI Inc. All Rights Reserved.
|
|
// Portions Copyright 2024 The OpenAgent 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 object
|
|
|
|
import (
|
|
"fmt"
|
|
|
|
"github.com/hanzoai/ai/agent"
|
|
"github.com/hanzoai/ai/embedding"
|
|
"github.com/hanzoai/ai/i18n"
|
|
"github.com/hanzoai/ai/model"
|
|
"github.com/hanzoai/ai/util"
|
|
"github.com/hanzoai/ai/video"
|
|
)
|
|
|
|
func getModelProviderFromName(owner string, providerName string, lang string) (*Provider, model.ModelProvider, error) {
|
|
var provider *Provider
|
|
var err error
|
|
if providerName != "" {
|
|
providerId := util.GetIdFromOwnerAndName(owner, providerName)
|
|
provider, err = GetProvider(providerId)
|
|
} else {
|
|
provider, err = GetDefaultModelProvider()
|
|
}
|
|
if err != nil {
|
|
return nil, nil, err
|
|
}
|
|
if provider == nil {
|
|
if providerName != "" {
|
|
return nil, nil, fmt.Errorf("%s", fmt.Sprintf(i18n.Translate(lang, "object:The model provider: %s is not found"), providerName))
|
|
} else {
|
|
return nil, nil, fmt.Errorf("%s", i18n.Translate(lang, "object:Please add a model provider first"))
|
|
}
|
|
}
|
|
if provider.Category != "Model" {
|
|
return nil, nil, fmt.Errorf("%s", fmt.Sprintf(i18n.Translate(lang, "object:The model provider: %s is expected to be \")Model\" category, got: \"%s\""), provider.GetId(), provider.Category))
|
|
}
|
|
// A disabled Model provider is unavailable — same admin toggle (State) the
|
|
// completion path honors via ModelProviderUsable, applied to the store /
|
|
// knowledge-base resolution path.
|
|
if !ModelProviderUsable(provider) {
|
|
return nil, nil, fmt.Errorf("%s", fmt.Sprintf(i18n.Translate(lang, "object:The model provider: %s is not found"), provider.GetId()))
|
|
}
|
|
if provider.ClientSecret == "" && provider.Type != "Dummy" && provider.Type != "Ollama" {
|
|
return nil, nil, fmt.Errorf("%s", fmt.Sprintf(i18n.Translate(lang, "object:The model provider: %s's client secret should not be empty"), provider.GetId()))
|
|
}
|
|
providerObj, err := provider.GetModelProvider(lang)
|
|
if err != nil {
|
|
return nil, nil, err
|
|
}
|
|
return provider, providerObj, err
|
|
}
|
|
|
|
func getEmbeddingProviderFromName(owner string, providerName string, lang string) (*Provider, embedding.EmbeddingProvider, error) {
|
|
var provider *Provider
|
|
var err error
|
|
if providerName != "" {
|
|
providerId := util.GetIdFromOwnerAndName(owner, providerName)
|
|
provider, err = GetProvider(providerId)
|
|
} else {
|
|
provider, err = GetDefaultEmbeddingProvider()
|
|
}
|
|
if err != nil {
|
|
return nil, nil, err
|
|
}
|
|
if provider == nil {
|
|
if providerName != "" {
|
|
return nil, nil, fmt.Errorf("%s", fmt.Sprintf(i18n.Translate(lang, "object:The embedding provider: %s is not found"), providerName))
|
|
} else {
|
|
return nil, nil, fmt.Errorf("%s", i18n.Translate(lang, "object:Please add an embedding provider first"))
|
|
}
|
|
}
|
|
if provider.Category != "Embedding" {
|
|
return nil, nil, fmt.Errorf("%s", fmt.Sprintf(i18n.Translate(lang, "object:The embedding provider: %s is expected to be \")Embedding\" category, got: \"%s\""), provider.GetId(), provider.Category))
|
|
}
|
|
// Force a KNOWN-BROKEN default embedder (api.openai.com-direct: empty or
|
|
// openai.com ProviderUrl) onto the configured Hanzo gateway at RESOLUTION
|
|
// time. In the fused cloud binary a server-side embed to api.openai.com from
|
|
// in-cluster crawls ~180s then fails (so RAG ingest hung AND the Qdrant
|
|
// collection was never created). Doing it here — not only in the InitDb seed
|
|
// — guarantees ingest/query embed through the gateway regardless of which
|
|
// record the default store resolves or whether the boot heal ran. A healthy
|
|
// custom embedder (any other non-empty, non-openai URL) is left untouched.
|
|
forceGatewayEmbedder(provider)
|
|
if provider.ClientSecret == "" && provider.Type != "Dummy" {
|
|
return nil, nil, fmt.Errorf("%s", fmt.Sprintf(i18n.Translate(lang, "object:The embedding provider: %s's client secret should not be empty"), provider.GetId()))
|
|
}
|
|
providerObj, err := provider.GetEmbeddingProvider(lang)
|
|
if err != nil {
|
|
return nil, nil, err
|
|
}
|
|
return provider, providerObj, err
|
|
}
|
|
|
|
func getAgentProviderFromName(owner string, providerName string, lang string) (*Provider, agent.AgentProvider, error) {
|
|
var provider *Provider
|
|
var err error
|
|
if providerName != "" {
|
|
providerId := util.GetIdFromOwnerAndName(owner, providerName)
|
|
provider, err = GetProvider(providerId)
|
|
} else {
|
|
provider, err = GetDefaultAgentProvider()
|
|
}
|
|
if err != nil {
|
|
return nil, nil, err
|
|
}
|
|
if provider == nil {
|
|
return nil, nil, nil
|
|
}
|
|
if provider.Category != "Agent" {
|
|
return nil, nil, fmt.Errorf("%s", fmt.Sprintf(i18n.Translate(lang, "object:The agent provider: %s is expected to be \")Agent\" category, got: \"%s\""), provider.GetId(), provider.Category))
|
|
}
|
|
providerObj, err := provider.GetAgentProvider(lang)
|
|
if err != nil {
|
|
return nil, nil, err
|
|
}
|
|
return provider, providerObj, err
|
|
}
|
|
|
|
func SetDefaultVodClient(lang string) error {
|
|
if video.VodClient != nil {
|
|
return nil
|
|
}
|
|
provider, err := GetDefaultVideoProvider()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if provider == nil {
|
|
return fmt.Errorf("%s", i18n.Translate(lang, "object:The default video provider should not be empty"))
|
|
}
|
|
err = video.SetVodClient(provider.Region, provider.ClientId, provider.ClientSecret)
|
|
return err
|
|
}
|
|
|
|
func getActiveCloudProviders(owner string) ([]*Provider, error) {
|
|
providers, err := GetProviders("admin")
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
res := []*Provider{}
|
|
for _, provider := range providers {
|
|
if provider.ClientId != "" && provider.ClientSecret != "" && (provider.Category == "Public Cloud" || provider.Category == "Private Cloud") && provider.State == "Active" {
|
|
res = append(res, provider)
|
|
}
|
|
}
|
|
return res, nil
|
|
}
|
|
|
|
func GetActiveBlockchainProvider(owner string) (*Provider, error) {
|
|
providers, err := GetProviders(owner)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
for _, provider := range providers {
|
|
if provider.Category == "Blockchain" && provider.IsDefault && provider.State == "Active" {
|
|
return provider, nil
|
|
}
|
|
}
|
|
for _, provider := range providers {
|
|
if ((provider.ClientId != "" && provider.ClientSecret != "") || (provider.ClientSecret != "" && provider.Type == "Ethereum") || provider.Type == "ChainMaker") && provider.Category == "Blockchain" && provider.State == "Active" {
|
|
return provider, nil
|
|
}
|
|
}
|
|
return nil, nil
|
|
}
|
|
|
|
func GetTwoActiveBlockchainProvider(owner string) (*Provider, *Provider, error) {
|
|
providers, err := GetProviders(owner)
|
|
if err != nil {
|
|
return nil, nil, err
|
|
}
|
|
var providerFirst, providerSecond *Provider
|
|
// Try to find the first default active blockchain provider
|
|
for _, provider := range providers {
|
|
if provider.Category == "Blockchain" && provider.IsDefault && provider.State == "Active" {
|
|
providerFirst = provider
|
|
break
|
|
}
|
|
}
|
|
// If the first provider is not found, try to find the first active blockchain provider,
|
|
// then find the second active blockchain provider
|
|
for _, provider := range providers {
|
|
if ((provider.ClientId != "" && provider.ClientSecret != "") || (provider.ClientSecret != "" && provider.Type == "Ethereum") || provider.Type == "ChainMaker") && provider.Category == "Blockchain" && provider.State == "Active" {
|
|
if providerFirst == nil {
|
|
providerFirst = provider
|
|
} else if provider.GetId() != providerFirst.GetId() {
|
|
providerSecond = provider
|
|
break
|
|
}
|
|
}
|
|
}
|
|
return providerFirst, providerSecond, nil
|
|
}
|
|
|
|
func generateProviderKey() string {
|
|
return fmt.Sprintf("sk-%s", util.GetRandomString(24))
|
|
}
|