mirror of
https://github.com/hanzoai/ai.git
synced 2026-11-20 14:13:23 +00:00
/v1/audio/speech has shipped OpenAI-shaped TTS since the audio group landed; STT never got its compat twin — api.hanzo.ai 404s /v1/audio/transcriptions and the only STT path is the legacy store-bound /v1/process-speech-to-text. Chat's composer therefore still listens with the browser recogniser (broken in Brave), and the intended upgrade recorded in universe's chat configmap is blocked on exactly this route. AudioTranscriptions mirrors AudioSpeech end to end: same bearer auth (pk- refused, auth before body validation so nothing is probe-able), same model-route resolution, same balance gate, same unpriced usage row + trace. Both surfaces stay in step — the beego controller and the ZAP-native handler (audio.transcribe, gateway path /v1/audio/transcriptions) — with the multipart body recovered from its own boundary line exactly as stt.process does. stt gains the OpenAI-compatible provider: any /v1 root that serves /audio/transcriptions (OpenAI itself, the in-cluster speech service, a BYO node) registers as Type OpenAI with ProviderUrl as the root. The factory takes flavor like the TTS factory always has; for STT it carries the audio's language hint, bound from the request's language field. Co-authored-by: Hanzo Dev <[email protected]>
605 lines
20 KiB
Go
605 lines
20 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 = "***"
|
|
|
|
func GetMaskedProvider(provider *Provider, isMaskEnabled bool, user *iam.User) *Provider {
|
|
if !isMaskEnabled {
|
|
return provider
|
|
}
|
|
if provider == nil {
|
|
return nil
|
|
}
|
|
if provider.ClientSecret != "" {
|
|
provider.ClientSecret = SecretMask
|
|
}
|
|
if !util.IsAdmin(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, isMaskEnabled bool, user *iam.User) []*Provider {
|
|
if !isMaskEnabled {
|
|
return providers
|
|
}
|
|
for _, provider := range providers {
|
|
provider = GetMaskedProvider(provider, isMaskEnabled, 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
|
|
}
|
|
if provider == 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 affected != 0
|
|
return true, nil
|
|
}
|
|
provider.Owner = owner
|
|
provider.Name = name
|
|
err = adapter.db.Model(provider).Update()
|
|
if err != nil {
|
|
return false, err
|
|
}
|
|
// return affected != 0
|
|
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"))
|
|
}
|
|
|
|
func (p *Provider) GetStorageProviderObj(vectorStoreId string, lang string) (storage.StorageProvider, error) {
|
|
pProvider, err := storage.GetStorageProvider(p.Type, p.ClientId, p.ClientSecret, p.Name, vectorStoreId, lang)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if pProvider == nil {
|
|
return nil, fmt.Errorf("%s", fmt.Sprintf(i18n.Translate(lang, "object:the storage provider type: %s is not supported"), p.Type))
|
|
}
|
|
return pProvider, nil
|
|
}
|
|
|
|
func (p *Provider) GetModelProvider(lang string) (model.ModelProvider, error) {
|
|
pProvider, err := model.GetModelProvider(p.Type, p.SubType, p.ClientId, p.ClientSecret, p.UserKey, p.Temperature, p.TopP, p.TopK, p.FrequencyPenalty, p.PresencePenalty, p.ProviderUrl, p.ApiVersion, p.CompatibleProvider, p.InputPricePerThousandTokens, p.OutputPricePerThousandTokens, p.Currency, p.EnableThinking)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if pProvider == nil {
|
|
return nil, fmt.Errorf("%s", fmt.Sprintf(i18n.Translate(lang, "object:the model provider type: %s is not supported"), p.Type))
|
|
}
|
|
return pProvider, nil
|
|
}
|
|
|
|
func (p *Provider) GetEmbeddingProvider(lang string) (embedding.EmbeddingProvider, error) {
|
|
pProvider, err := embedding.GetEmbeddingProvider(p.Type, p.SubType, p.ClientId, p.ClientSecret, p.ProviderUrl, p.ApiVersion, p.InputPricePerThousandTokens, p.Currency, lang)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if pProvider == nil {
|
|
return nil, fmt.Errorf("%s", fmt.Sprintf(i18n.Translate(lang, "object:the embedding provider type: %s is not supported"), p.Type))
|
|
}
|
|
return pProvider, nil
|
|
}
|
|
|
|
func (p *Provider) GetAgentProvider(lang string) (agent.AgentProvider, error) {
|
|
pProvider, err := agent.GetAgentProvider(p.Type, p.SubType, p.Text, p.McpTools, lang)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if pProvider == nil {
|
|
return nil, fmt.Errorf("%s", fmt.Sprintf(i18n.Translate(lang, "agent:the agent provider type: %s is not supported"), p.Type))
|
|
}
|
|
return pProvider, nil
|
|
}
|
|
|
|
func (p *Provider) GetTextToSpeechProvider(lang string) (tts.TextToSpeechProvider, error) {
|
|
pProvider, err := tts.GetTextToSpeechProvider(p.Type, p.SubType, p.ClientId, p.ClientSecret, p.ProviderUrl, p.ApiVersion, p.InputPricePerThousandTokens, p.Currency, p.Flavor, lang)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if pProvider == nil {
|
|
return nil, fmt.Errorf("%s", fmt.Sprintf(i18n.Translate(lang, "object:the TTS provider type: %s is not supported"), p.Type))
|
|
}
|
|
return pProvider, nil
|
|
}
|
|
|
|
func (p *Provider) GetSpeechToTextProvider(lang string) (stt.SpeechToTextProvider, error) {
|
|
pProvider, err := stt.GetSpeechToTextProvider(p.Type, p.SubType, p.ClientSecret, p.ProviderUrl, p.Flavor)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if pProvider == nil {
|
|
return nil, fmt.Errorf("%s", fmt.Sprintf(i18n.Translate(lang, "object:the STT provider type: %s is not supported"), p.Type))
|
|
}
|
|
return pProvider, nil
|
|
}
|
|
|
|
func (p *Provider) GetScanProvider(lang string) (scan.ScanProvider, error) {
|
|
pProvider, err := scan.GetScanProvider(p.Type, p.ClientId, lang)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if pProvider == nil {
|
|
return nil, fmt.Errorf("%s", fmt.Sprintf(i18n.Translate(lang, "object:the scan provider type: %s is not supported"), p.Type))
|
|
}
|
|
return pProvider, nil
|
|
}
|
|
|
|
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
|
|
}
|
|
}
|