mirror of
https://github.com/hanzoai/ai.git
synced 2026-11-20 14:13:23 +00:00
622 lines
22 KiB
Go
622 lines
22 KiB
Go
// Copyright 2023-2025 Hanzo AI Inc. All Rights Reserved.
|
|
// Portions Copyright 2023 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"
|
|
"strings"
|
|
|
|
"github.com/hanzoai/ai/agent"
|
|
"github.com/hanzoai/ai/embedding"
|
|
"github.com/hanzoai/ai/i18n"
|
|
iam "github.com/hanzoai/ai/internal/iam"
|
|
"github.com/hanzoai/ai/model"
|
|
"github.com/hanzoai/ai/scan"
|
|
"github.com/hanzoai/ai/storage"
|
|
"github.com/hanzoai/ai/stt"
|
|
"github.com/hanzoai/ai/tts"
|
|
"github.com/hanzoai/ai/util"
|
|
"github.com/hanzoai/dbx"
|
|
)
|
|
|
|
type Provider struct {
|
|
Owner string `db:"pk" json:"owner"`
|
|
Name string `db:"pk" json:"name"`
|
|
CreatedTime string `json:"createdTime"`
|
|
DisplayName string `json:"displayName"`
|
|
Category string `json:"category"`
|
|
Type string `json:"type"`
|
|
SubType string `json:"subType"`
|
|
Flavor string `json:"flavor"`
|
|
ClientId string `json:"clientId"`
|
|
ClientSecret string `json:"clientSecret"`
|
|
Region string `json:"region"`
|
|
ProviderKey string `json:"providerKey"`
|
|
ProviderUrl string `json:"providerUrl"`
|
|
ApiVersion string `json:"apiVersion"`
|
|
CompatibleProvider string `json:"compatibleProvider"`
|
|
McpTools agent.McpToolsList `json:"mcpTools"`
|
|
Text string `json:"text"`
|
|
ConfigText string `json:"configText"`
|
|
RawText string `json:"rawText"` // Raw result from scan (for Scan category providers)
|
|
EnableThinking bool `json:"enableThinking"`
|
|
Temperature float32 `json:"temperature"`
|
|
TopP float32 `json:"topP"`
|
|
TopK int `json:"topK"`
|
|
FrequencyPenalty float32 `json:"frequencyPenalty"`
|
|
PresencePenalty float32 `json:"presencePenalty"`
|
|
InputPricePerThousandTokens float64 `json:"inputPricePerThousandTokens"`
|
|
OutputPricePerThousandTokens float64 `json:"outputPricePerThousandTokens"`
|
|
Currency string `json:"currency"`
|
|
UserKey string `json:"userKey"`
|
|
UserCert string `json:"userCert"`
|
|
SignKey string `json:"signKey"`
|
|
SignCert string `json:"signCert"`
|
|
ContractName string `json:"contractName"`
|
|
ContractMethod string `json:"contractMethod"`
|
|
Network string `json:"network"`
|
|
Chain string `json:"chain"`
|
|
TestContent string `json:"testContent"`
|
|
// New fields for unified scan widget (for Scan category providers)
|
|
TargetMode string `json:"targetMode"` // "Manual Input" or "Asset"
|
|
Target string `json:"target"` // Manual input target (IP address or network range)
|
|
Asset string `json:"asset"` // Selected asset for scan
|
|
Runner string `json:"runner"` // Hostname about who runs the scan job
|
|
ErrorText string `json:"errorText"` // Error message for the job execution
|
|
ResultSummary string `json:"resultSummary"` // Short summary of scan results
|
|
IsDefault bool `json:"isDefault"`
|
|
IsRemote bool `json:"isRemote"`
|
|
State string `json:"state"`
|
|
BrowserUrl string `json:"browserUrl"`
|
|
}
|
|
|
|
// SecretMask is what the admin API returns in place of a stored secret, and
|
|
// therefore what the console posts back when an operator saves a form without
|
|
// touching the key field. Every site that hides a secret or recognises the
|
|
// placeholder on the way back in uses THIS — a masked value that one site writes
|
|
// and another fails to recognise is a value written into the store as if it were
|
|
// a key.
|
|
const SecretMask = "***"
|
|
|
|
// GetMaskedProvider returns the row with its credentials replaced by SecretMask,
|
|
// keeping only what the caller is entitled to read.
|
|
//
|
|
// There is no "skip the masking" argument. It had one, every call site passed
|
|
// true, and the false branch returned the row with every key in the clear — a
|
|
// default that only had to be reached once to spend real money. A caller that
|
|
// genuinely needs a live credential reads the row it already holds.
|
|
func GetMaskedProvider(provider *Provider, user *iam.User) *Provider {
|
|
if provider == nil {
|
|
return nil
|
|
}
|
|
if provider.ClientSecret != "" {
|
|
provider.ClientSecret = SecretMask
|
|
}
|
|
// These four fields are PLATFORM upstream credentials — the money that buys a
|
|
// call from OpenAI, Anthropic, OpenRouter, Fireworks. Whoever can read one can
|
|
// spend it directly, off our meter, so the predicate that unmasks them is the
|
|
// platform one: membership in the reserved admin org.
|
|
//
|
|
// IsAdmin is a TENANT fact — every customer who administers their own org
|
|
// satisfies it — and a global provider row belongs to no tenant. IsSuperAdmin is
|
|
// the narrower predicate IsAdmin's own doc comment names for exactly this
|
|
// operation ("provider/upstream-key config"), and it is the one predicate the
|
|
// whole estate agrees on: owner == AdminOrg.
|
|
if !util.IsSuperAdmin(user) {
|
|
if provider.ProviderKey != "" {
|
|
provider.ProviderKey = SecretMask
|
|
}
|
|
if provider.UserKey != "" {
|
|
provider.UserKey = SecretMask
|
|
}
|
|
if provider.ConfigText != "" {
|
|
provider.ConfigText = SecretMask
|
|
}
|
|
if provider.SignKey != "" {
|
|
provider.SignKey = SecretMask
|
|
}
|
|
}
|
|
return provider
|
|
}
|
|
|
|
func GetMaskedProviders(providers []*Provider, user *iam.User) []*Provider {
|
|
for _, provider := range providers {
|
|
GetMaskedProvider(provider, user)
|
|
}
|
|
return providers
|
|
}
|
|
|
|
func GetGlobalProviders() ([]*Provider, error) {
|
|
providers := []*Provider{}
|
|
err := findAll(adapter.db, "provider", &providers, nil, "owner ASC", "created_time DESC")
|
|
if err != nil {
|
|
return providers, err
|
|
}
|
|
if providerAdapter != nil {
|
|
providers2 := []*Provider{}
|
|
err = findAll(providerAdapter.db, "provider", &providers2, nil, "owner ASC", "created_time DESC")
|
|
if err != nil {
|
|
return providers2, err
|
|
}
|
|
// Mark remote providers
|
|
for _, provider := range providers2 {
|
|
provider.IsRemote = true
|
|
}
|
|
providers = append(providers, providers2...)
|
|
}
|
|
return providers, nil
|
|
}
|
|
|
|
func GetProviders(owner string) ([]*Provider, error) {
|
|
providers := []*Provider{}
|
|
err := findAll(adapter.db, "provider", &providers, dbx.HashExp{"owner": owner}, "created_time DESC")
|
|
if err != nil {
|
|
return providers, err
|
|
}
|
|
if providerAdapter != nil {
|
|
providers2 := []*Provider{}
|
|
err = findAll(providerAdapter.db, "provider", &providers2, dbx.HashExp{"owner": owner}, "created_time DESC")
|
|
if err != nil {
|
|
return providers2, err
|
|
}
|
|
// Mark remote providers
|
|
for _, provider := range providers2 {
|
|
provider.IsRemote = true
|
|
}
|
|
providers = append(providers, providers2...)
|
|
}
|
|
return providers, nil
|
|
}
|
|
|
|
func getProvider(owner string, name string) (*Provider, error) {
|
|
// No store is "I cannot answer", not a crash. This reads adapter.db, which is
|
|
// nil before the DB is initialised — during boot, in the standalone runtime
|
|
// with no driverName, and in every unit test — so an unguarded read turns a
|
|
// missing dependency into a SIGSEGV at whatever call site happened to ask
|
|
// first. Callers already handle (nil, err).
|
|
if adapter == nil || adapter.db == nil {
|
|
return nil, fmt.Errorf("provider store is not initialised")
|
|
}
|
|
provider := Provider{Owner: owner, Name: name}
|
|
existed, err := getOne(adapter.db, "provider", &provider, pk2(provider.Owner, provider.Name))
|
|
if err != nil {
|
|
return &provider, err
|
|
}
|
|
if providerAdapter != nil && !existed {
|
|
existed, err = getOne(providerAdapter.db, "provider", &provider, pk2(provider.Owner, provider.Name))
|
|
if err != nil {
|
|
return &provider, err
|
|
}
|
|
if existed {
|
|
provider.IsRemote = true
|
|
}
|
|
}
|
|
if existed {
|
|
return &provider, nil
|
|
} else {
|
|
return nil, nil
|
|
}
|
|
}
|
|
|
|
func GetProvider(id string) (*Provider, error) {
|
|
owner, name, err := util.GetOwnerAndNameFromIdWithError(id)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return getProvider(owner, name)
|
|
}
|
|
|
|
func UpdateProvider(id string, provider *Provider) (bool, error) {
|
|
owner, name, err := util.GetOwnerAndNameFromIdWithError(id)
|
|
if err != nil {
|
|
return false, err
|
|
}
|
|
providerDb, err := getProvider(owner, name)
|
|
if err != nil {
|
|
return false, err
|
|
}
|
|
// getProvider answers (nil, nil) for a name no row matches. There is nothing to
|
|
// update, which is what false says — and it has to be said here: the merge below
|
|
// reads the stored row to fill in the secrets a request sends masked, so an
|
|
// absent one is a dereference on the ordinary edit-form round trip.
|
|
if provider == nil || providerDb == nil {
|
|
return false, nil
|
|
}
|
|
provider.processProviderParams(providerDb)
|
|
if providerAdapter != nil && provider.IsRemote {
|
|
provider.Owner = owner
|
|
provider.Name = name
|
|
err = providerAdapter.db.Model(provider).Update()
|
|
if err != nil {
|
|
return false, err
|
|
}
|
|
return true, nil
|
|
}
|
|
provider.Owner = owner
|
|
provider.Name = name
|
|
err = adapter.db.Model(provider).Update()
|
|
if err != nil {
|
|
return false, err
|
|
}
|
|
return true, nil
|
|
}
|
|
|
|
func AddProvider(provider *Provider) (bool, error) {
|
|
if provider.ProviderKey == "" && provider.Category == "Model" {
|
|
provider.ProviderKey = generateProviderKey()
|
|
}
|
|
if providerAdapter != nil && provider.IsRemote {
|
|
err := insertRow(providerAdapter.db, provider)
|
|
if err != nil {
|
|
return false, err
|
|
}
|
|
return true, nil
|
|
}
|
|
err := insertRow(adapter.db, provider)
|
|
if err != nil {
|
|
return false, err
|
|
}
|
|
return true, nil
|
|
}
|
|
|
|
func DeleteProvider(provider *Provider) (bool, error) {
|
|
if providerAdapter != nil && provider.IsRemote {
|
|
affected, err := deleteByPK(providerAdapter.db, "provider", pk2(provider.Owner, provider.Name))
|
|
if err != nil {
|
|
return false, err
|
|
}
|
|
return affected != 0, nil
|
|
}
|
|
affected, err := deleteByPK(adapter.db, "provider", pk2(provider.Owner, provider.Name))
|
|
if err != nil {
|
|
return false, err
|
|
}
|
|
return affected != 0, nil
|
|
}
|
|
|
|
func (provider *Provider) GetId() string {
|
|
return fmt.Sprintf("%s/%s", provider.Owner, provider.Name)
|
|
}
|
|
|
|
func GetDefaultKubernetesProvider(lang string) (*Provider, error) {
|
|
providers, err := GetProviders("admin")
|
|
if err != nil {
|
|
return nil, fmt.Errorf("%s", fmt.Sprintf(i18n.Translate(lang, "object:failed to get providers: %v"), err))
|
|
}
|
|
for _, provider := range providers {
|
|
if provider.Category == "Private Cloud" && provider.Type == "Kubernetes" && provider.State == "Active" {
|
|
return provider, nil
|
|
}
|
|
}
|
|
return nil, fmt.Errorf("%s", i18n.Translate(lang, "object:no Kubernetes provider found"))
|
|
}
|
|
|
|
// supported turns a provider constructor's answer into one answer.
|
|
//
|
|
// Every constructor below reports an unknown Type the same way — no error and no
|
|
// provider — so a nil that arrives without one means we do not speak that type,
|
|
// which is an error rather than a nil to carry off. That is the whole of what the
|
|
// seven differed in nothing but, and each still names its own message because the
|
|
// keys are what the locale files hold.
|
|
func supported[T any](made T, err error, key string, providerType string, lang string) (T, error) {
|
|
var none T
|
|
if err != nil {
|
|
return none, err
|
|
}
|
|
if any(made) == nil {
|
|
return none, fmt.Errorf("%s", fmt.Sprintf(i18n.Translate(lang, key), providerType))
|
|
}
|
|
return made, nil
|
|
}
|
|
|
|
func (p *Provider) GetStorageProviderObj(vectorStoreId string, lang string) (storage.StorageProvider, error) {
|
|
made, err := storage.GetStorageProvider(p.Type, p.ClientId, p.ClientSecret, p.Name, vectorStoreId, lang)
|
|
return supported(made, err, "object:the storage provider type: %s is not supported", p.Type, lang)
|
|
}
|
|
|
|
func (p *Provider) GetModelProvider(lang string) (model.ModelProvider, error) {
|
|
made, err := model.Open(model.Spec{
|
|
Upstream: model.Upstream(p.Type),
|
|
Model: p.SubType,
|
|
ClientID: p.ClientId,
|
|
Secret: p.ClientSecret,
|
|
UserKey: p.UserKey,
|
|
URL: p.ProviderUrl,
|
|
APIVersion: p.ApiVersion,
|
|
Compatible: p.CompatibleProvider,
|
|
Temperature: p.Temperature,
|
|
TopP: p.TopP,
|
|
TopK: p.TopK,
|
|
Frequency: p.FrequencyPenalty,
|
|
Presence: p.PresencePenalty,
|
|
Thinking: p.EnableThinking,
|
|
InputPrice: p.InputPricePerThousandTokens,
|
|
OutputPrice: p.OutputPricePerThousandTokens,
|
|
Currency: p.Currency,
|
|
})
|
|
return supported(made, err, "object:the model provider type: %s is not supported", p.Type, lang)
|
|
}
|
|
|
|
func (p *Provider) GetEmbeddingProvider(lang string) (embedding.EmbeddingProvider, error) {
|
|
made, err := embedding.Open(embedding.Spec{
|
|
Upstream: model.Upstream(p.Type),
|
|
Model: p.SubType,
|
|
ClientID: p.ClientId,
|
|
Secret: p.ClientSecret,
|
|
URL: p.ProviderUrl,
|
|
APIVersion: p.ApiVersion,
|
|
Price: p.InputPricePerThousandTokens,
|
|
Currency: p.Currency,
|
|
Lang: lang,
|
|
})
|
|
return supported(made, err, "object:the embedding provider type: %s is not supported", p.Type, lang)
|
|
}
|
|
|
|
func (p *Provider) GetAgentProvider(lang string) (agent.AgentProvider, error) {
|
|
made, err := agent.GetAgentProvider(p.Type, p.SubType, p.Text, p.McpTools, lang)
|
|
return supported(made, err, "agent:the agent provider type: %s is not supported", p.Type, lang)
|
|
}
|
|
|
|
func (p *Provider) GetTextToSpeechProvider(lang string, format string) (tts.TextToSpeechProvider, error) {
|
|
made, err := tts.GetTextToSpeechProvider(p.Type, p.SubType, p.ClientId, p.ClientSecret, p.ProviderUrl, p.ApiVersion, p.InputPricePerThousandTokens, p.Currency, p.Flavor, format, lang)
|
|
return supported(made, err, "object:the TTS provider type: %s is not supported", p.Type, lang)
|
|
}
|
|
|
|
func (p *Provider) GetSpeechToTextProvider(lang string) (stt.SpeechToTextProvider, error) {
|
|
made, err := stt.GetSpeechToTextProvider(p.Type, p.SubType, p.ClientSecret, p.ProviderUrl, p.Flavor)
|
|
return supported(made, err, "object:the STT provider type: %s is not supported", p.Type, lang)
|
|
}
|
|
|
|
func (p *Provider) GetScanProvider(lang string) (scan.ScanProvider, error) {
|
|
made, err := scan.GetScanProvider(p.Type, p.ClientId, lang)
|
|
return supported(made, err, "object:the scan provider type: %s is not supported", p.Type, lang)
|
|
}
|
|
|
|
func GetModelProviderFromContext(owner string, name string, lang string) (*Provider, model.ModelProvider, error) {
|
|
var providerName string
|
|
if name != "" {
|
|
providerName = name
|
|
} else {
|
|
store, err := GetDefaultStore(owner)
|
|
if err != nil {
|
|
return nil, nil, err
|
|
}
|
|
if store != nil && store.ModelProvider != "" {
|
|
providerName = store.ModelProvider
|
|
}
|
|
}
|
|
return getModelProviderFromName(owner, providerName, lang)
|
|
}
|
|
|
|
func GetEmbeddingProviderFromContext(owner string, name string, lang string) (*Provider, embedding.EmbeddingProvider, error) {
|
|
var providerName string
|
|
if name != "" {
|
|
providerName = name
|
|
} else {
|
|
store, err := GetDefaultStore(owner)
|
|
if err != nil {
|
|
return nil, nil, err
|
|
}
|
|
if store != nil && store.EmbeddingProvider != "" {
|
|
providerName = store.EmbeddingProvider
|
|
}
|
|
}
|
|
return getEmbeddingProviderFromName(owner, providerName, lang)
|
|
}
|
|
|
|
func GetAgentProviderFromContext(owner string, name string, lang string) (*Provider, agent.AgentProvider, error) {
|
|
var providerName string
|
|
if name != "" {
|
|
providerName = name
|
|
} else {
|
|
store, err := GetDefaultStore(owner)
|
|
if err != nil {
|
|
return nil, nil, err
|
|
}
|
|
if store != nil && store.AgentProvider != "" {
|
|
providerName = store.AgentProvider
|
|
}
|
|
}
|
|
return getAgentProviderFromName(owner, providerName, lang)
|
|
}
|
|
|
|
func GetAgentClients(agentProviderObj agent.AgentProvider) (*agent.AgentClients, error) {
|
|
if agentProviderObj == nil {
|
|
return nil, nil
|
|
}
|
|
return agentProviderObj.GetAgentClients()
|
|
}
|
|
|
|
func GetProviderCount(owner, storeName, field, value string) (int64, error) {
|
|
session := GetDbQuery(owner, -1, -1, field, value, "", "")
|
|
if storeName != "" {
|
|
store, err := GetStore(util.GetIdFromOwnerAndName(owner, storeName))
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
providerNames := collectProviderNames(store)
|
|
if len(providerNames) > 0 {
|
|
session = session.AndWhere(dbx.In("name", toInterfaceSlice(providerNames)...))
|
|
}
|
|
}
|
|
count, err := queryCount(session, "provider")
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
// Add count from remote adapter if available
|
|
if providerAdapter != nil {
|
|
session2, err := buildRemoteProviderQuery(owner, field, value, storeName)
|
|
if err != nil {
|
|
return count, err
|
|
}
|
|
count2, err := queryCount(session2, "provider")
|
|
if err != nil {
|
|
return count, err
|
|
}
|
|
count += count2
|
|
}
|
|
return count, nil
|
|
}
|
|
|
|
func collectProviderNames(store *Store) []string {
|
|
var providerNames []string
|
|
if store.StorageProvider != "" {
|
|
providerNames = append(providerNames, store.StorageProvider)
|
|
}
|
|
if store.ImageProvider != "" {
|
|
providerNames = append(providerNames, store.ImageProvider)
|
|
}
|
|
if store.SplitProvider != "" {
|
|
providerNames = append(providerNames, store.SplitProvider)
|
|
}
|
|
if store.SearchProvider != "" {
|
|
providerNames = append(providerNames, store.SearchProvider)
|
|
}
|
|
if store.ModelProvider != "" {
|
|
providerNames = append(providerNames, store.ModelProvider)
|
|
}
|
|
if store.EmbeddingProvider != "" {
|
|
providerNames = append(providerNames, store.EmbeddingProvider)
|
|
}
|
|
if store.TextToSpeechProvider != "" {
|
|
providerNames = append(providerNames, store.TextToSpeechProvider)
|
|
}
|
|
if store.SpeechToTextProvider != "" {
|
|
providerNames = append(providerNames, store.SpeechToTextProvider)
|
|
}
|
|
if store.AgentProvider != "" {
|
|
providerNames = append(providerNames, store.AgentProvider)
|
|
}
|
|
if store.ChildModelProviders != nil {
|
|
providerNames = append(providerNames, store.ChildModelProviders...)
|
|
}
|
|
return providerNames
|
|
}
|
|
|
|
func buildRemoteProviderQuery(owner, field, value, storeName string) (*dbx.SelectQuery, error) {
|
|
if providerAdapter == nil {
|
|
return nil, fmt.Errorf("providerAdapter is nil")
|
|
}
|
|
q := providerAdapter.db.Select().From("provider")
|
|
if owner != "" {
|
|
q = q.AndWhere(dbx.HashExp{"owner": owner})
|
|
}
|
|
if field != "" && value != "" {
|
|
if util.FilterField(field) {
|
|
q = q.AndWhere(dbx.Like(util.SnakeString(field), value))
|
|
}
|
|
}
|
|
if storeName != "" {
|
|
store, err := GetStore(util.GetIdFromOwnerAndName(owner, storeName))
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
providerNames := collectProviderNames(store)
|
|
if len(providerNames) > 0 {
|
|
q = q.AndWhere(dbx.In("name", toInterfaceSlice(providerNames)...))
|
|
}
|
|
}
|
|
return q, nil
|
|
}
|
|
|
|
func GetPaginationProviders(owner, storeName string, offset, limit int, field, value, sortField, sortOrder string) ([]*Provider, error) {
|
|
providers := []*Provider{}
|
|
// Fetch from local adapter without pagination to properly merge with remote providers
|
|
session := GetDbQuery(owner, -1, -1, field, value, sortField, sortOrder)
|
|
if storeName != "" {
|
|
store, err := GetStore(util.GetIdFromOwnerAndName(owner, storeName))
|
|
if err != nil {
|
|
return providers, err
|
|
}
|
|
providerNames := collectProviderNames(store)
|
|
if len(providerNames) > 0 {
|
|
session = session.AndWhere(dbx.In("name", toInterfaceSlice(providerNames)...))
|
|
}
|
|
}
|
|
err := queryFind(session, "provider", &providers)
|
|
if err != nil {
|
|
return providers, err
|
|
}
|
|
// Fetch from remote adapter if available
|
|
if providerAdapter != nil {
|
|
providers2 := []*Provider{}
|
|
session2, err := buildRemoteProviderQuery(owner, field, value, storeName)
|
|
if err != nil {
|
|
return providers, err
|
|
}
|
|
// Same sort as the local half above, through the same whitelist. These
|
|
// two result sets are concatenated, so they must agree on the column as
|
|
// well as on the direction — and this half reads a DIFFERENT database,
|
|
// which is what an unchecked ORDER BY here would let a caller walk.
|
|
session2 = session2.OrderBy(sortColumn(sortField, sortOrder) + sortDirection(sortOrder))
|
|
err = queryFind(session2, "provider", &providers2)
|
|
if err != nil {
|
|
return providers, err
|
|
}
|
|
// Mark remote providers
|
|
for _, provider := range providers2 {
|
|
provider.IsRemote = true
|
|
}
|
|
// Append remote providers after local providers
|
|
providers = append(providers, providers2...)
|
|
}
|
|
// Apply pagination on merged results
|
|
if offset != -1 && limit != -1 {
|
|
start := offset
|
|
end := offset + limit
|
|
if start >= len(providers) {
|
|
return []*Provider{}, nil
|
|
}
|
|
if end > len(providers) {
|
|
end = len(providers)
|
|
}
|
|
providers = providers[start:end]
|
|
}
|
|
return providers, nil
|
|
}
|
|
|
|
func RefreshMcpTools(provider *Provider) error {
|
|
tools, err := agent.GetToolsList(provider.Text)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
provider.McpTools = tools
|
|
return nil
|
|
}
|
|
|
|
func (p *Provider) processProviderParams(providerDb *Provider) {
|
|
if p.ClientSecret == SecretMask {
|
|
p.ClientSecret = providerDb.ClientSecret
|
|
}
|
|
if p.UserKey == SecretMask {
|
|
p.UserKey = providerDb.UserKey
|
|
}
|
|
if p.SignKey == SecretMask {
|
|
p.SignKey = providerDb.SignKey
|
|
}
|
|
if p.ProviderKey == "" && p.Category == "Model" {
|
|
p.ProviderKey = generateProviderKey()
|
|
}
|
|
if p.Type == "Ollama" && p.ProviderUrl != "" && !strings.HasPrefix(p.ProviderUrl, "http") {
|
|
p.ProviderUrl = "http://" + p.ProviderUrl
|
|
}
|
|
if p.Category == "Model" && p.Type == "OpenAI" && (strings.Contains(p.SubType, "o1") || strings.Contains(p.SubType, "o3") || strings.Contains(p.SubType, "o4")) {
|
|
p.Temperature = 1
|
|
p.TopP = 1
|
|
p.FrequencyPenalty = 0
|
|
p.PresencePenalty = 0
|
|
}
|
|
}
|