mirror of
https://github.com/Finesssee/ProxyPilot.git
synced 2026-11-19 02:17:46 +00:00
refactor(auth): split conductor.go into logical modules
Split the 2,280-line conductor.go into three focused files: - conductor.go (1,416 lines): Core types, Manager struct, execution - conductor_oauth.go (383 lines): OAuth/API key model alias resolution - conductor_token.go (501 lines): Token refresh and HTTP request handling This is a pure refactor with no logic changes. Co-Authored-By: Claude (gemini-claude-opus-4-5-thinking) <noreply@anthropic.com>
This commit is contained in:
@@ -1,14 +1,10 @@
|
||||
package auth
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"context"
|
||||
"encoding/json"
|
||||
"errors"
|
||||
"io"
|
||||
"net/http"
|
||||
"path/filepath"
|
||||
"strconv"
|
||||
"strings"
|
||||
"sync"
|
||||
"sync/atomic"
|
||||
@@ -207,168 +203,6 @@ func (m *Manager) SetConfig(cfg *internalconfig.Config) {
|
||||
m.rebuildAPIKeyModelAliasFromRuntimeConfig()
|
||||
}
|
||||
|
||||
func (m *Manager) lookupAPIKeyUpstreamModel(authID, requestedModel string) string {
|
||||
if m == nil {
|
||||
return ""
|
||||
}
|
||||
authID = strings.TrimSpace(authID)
|
||||
if authID == "" {
|
||||
return ""
|
||||
}
|
||||
requestedModel = strings.TrimSpace(requestedModel)
|
||||
if requestedModel == "" {
|
||||
return ""
|
||||
}
|
||||
table, _ := m.apiKeyModelAlias.Load().(apiKeyModelAliasTable)
|
||||
if table == nil {
|
||||
return ""
|
||||
}
|
||||
byAlias := table[authID]
|
||||
if len(byAlias) == 0 {
|
||||
return ""
|
||||
}
|
||||
key := strings.ToLower(thinking.ParseSuffix(requestedModel).ModelName)
|
||||
if key == "" {
|
||||
key = strings.ToLower(requestedModel)
|
||||
}
|
||||
resolved := strings.TrimSpace(byAlias[key])
|
||||
if resolved == "" {
|
||||
return ""
|
||||
}
|
||||
// Preserve thinking suffix from the client's requested model unless config already has one.
|
||||
requestResult := thinking.ParseSuffix(requestedModel)
|
||||
if thinking.ParseSuffix(resolved).HasSuffix {
|
||||
return resolved
|
||||
}
|
||||
if requestResult.HasSuffix && requestResult.RawSuffix != "" {
|
||||
return resolved + "(" + requestResult.RawSuffix + ")"
|
||||
}
|
||||
return resolved
|
||||
|
||||
}
|
||||
|
||||
func (m *Manager) rebuildAPIKeyModelAliasFromRuntimeConfig() {
|
||||
if m == nil {
|
||||
return
|
||||
}
|
||||
cfg, _ := m.runtimeConfig.Load().(*internalconfig.Config)
|
||||
if cfg == nil {
|
||||
cfg = &internalconfig.Config{}
|
||||
}
|
||||
m.mu.Lock()
|
||||
defer m.mu.Unlock()
|
||||
m.rebuildAPIKeyModelAliasLocked(cfg)
|
||||
}
|
||||
|
||||
func (m *Manager) rebuildAPIKeyModelAliasLocked(cfg *internalconfig.Config) {
|
||||
if m == nil {
|
||||
return
|
||||
}
|
||||
if cfg == nil {
|
||||
cfg = &internalconfig.Config{}
|
||||
}
|
||||
|
||||
out := make(apiKeyModelAliasTable)
|
||||
for _, auth := range m.auths {
|
||||
if auth == nil {
|
||||
continue
|
||||
}
|
||||
if strings.TrimSpace(auth.ID) == "" {
|
||||
continue
|
||||
}
|
||||
kind, _ := auth.AccountInfo()
|
||||
if !strings.EqualFold(strings.TrimSpace(kind), "api_key") {
|
||||
continue
|
||||
}
|
||||
|
||||
byAlias := make(map[string]string)
|
||||
provider := strings.ToLower(strings.TrimSpace(auth.Provider))
|
||||
switch provider {
|
||||
case "gemini":
|
||||
if entry := resolveGeminiAPIKeyConfig(cfg, auth); entry != nil {
|
||||
compileAPIKeyModelAliasForModels(byAlias, entry.Models)
|
||||
}
|
||||
case "claude":
|
||||
if entry := resolveClaudeAPIKeyConfig(cfg, auth); entry != nil {
|
||||
compileAPIKeyModelAliasForModels(byAlias, entry.Models)
|
||||
}
|
||||
case "codex":
|
||||
if entry := resolveCodexAPIKeyConfig(cfg, auth); entry != nil {
|
||||
compileAPIKeyModelAliasForModels(byAlias, entry.Models)
|
||||
}
|
||||
case "vertex":
|
||||
if entry := resolveVertexAPIKeyConfig(cfg, auth); entry != nil {
|
||||
compileAPIKeyModelAliasForModels(byAlias, entry.Models)
|
||||
}
|
||||
default:
|
||||
// OpenAI-compat uses config selection from auth.Attributes.
|
||||
providerKey := ""
|
||||
compatName := ""
|
||||
if auth.Attributes != nil {
|
||||
providerKey = strings.TrimSpace(auth.Attributes["provider_key"])
|
||||
compatName = strings.TrimSpace(auth.Attributes["compat_name"])
|
||||
}
|
||||
if compatName != "" || strings.EqualFold(strings.TrimSpace(auth.Provider), "openai-compatibility") {
|
||||
if entry := resolveOpenAICompatConfig(cfg, providerKey, compatName, auth.Provider); entry != nil {
|
||||
compileAPIKeyModelAliasForModels(byAlias, entry.Models)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if len(byAlias) > 0 {
|
||||
out[auth.ID] = byAlias
|
||||
}
|
||||
}
|
||||
|
||||
m.apiKeyModelAlias.Store(out)
|
||||
}
|
||||
|
||||
func compileAPIKeyModelAliasForModels[T interface {
|
||||
GetName() string
|
||||
GetAlias() string
|
||||
}](out map[string]string, models []T) {
|
||||
if out == nil {
|
||||
return
|
||||
}
|
||||
for i := range models {
|
||||
alias := strings.TrimSpace(models[i].GetAlias())
|
||||
name := strings.TrimSpace(models[i].GetName())
|
||||
if alias == "" || name == "" {
|
||||
continue
|
||||
}
|
||||
aliasKey := strings.ToLower(thinking.ParseSuffix(alias).ModelName)
|
||||
if aliasKey == "" {
|
||||
aliasKey = strings.ToLower(alias)
|
||||
}
|
||||
// Config priority: first alias wins.
|
||||
if _, exists := out[aliasKey]; exists {
|
||||
continue
|
||||
}
|
||||
out[aliasKey] = name
|
||||
// Also allow direct lookup by upstream name (case-insensitive), so lookups on already-upstream
|
||||
// models remain a cheap no-op.
|
||||
nameKey := strings.ToLower(thinking.ParseSuffix(name).ModelName)
|
||||
if nameKey == "" {
|
||||
nameKey = strings.ToLower(name)
|
||||
}
|
||||
if nameKey != "" {
|
||||
if _, exists := out[nameKey]; !exists {
|
||||
out[nameKey] = name
|
||||
}
|
||||
}
|
||||
// Preserve config suffix priority by seeding a base-name lookup when name already has suffix.
|
||||
nameResult := thinking.ParseSuffix(name)
|
||||
if nameResult.HasSuffix {
|
||||
baseKey := strings.ToLower(strings.TrimSpace(nameResult.ModelName))
|
||||
if baseKey != "" {
|
||||
if _, exists := out[baseKey]; !exists {
|
||||
out[baseKey] = name
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// SetRetryConfig updates retry attempts and cooldown wait interval.
|
||||
func (m *Manager) SetRetryConfig(retry int, maxRetryInterval time.Duration) {
|
||||
if m == nil {
|
||||
@@ -804,218 +638,6 @@ func rewriteModelForAuth(model string, auth *Auth) string {
|
||||
return strings.TrimPrefix(model, needle)
|
||||
}
|
||||
|
||||
func (m *Manager) applyAPIKeyModelAlias(auth *Auth, requestedModel string) string {
|
||||
if m == nil || auth == nil {
|
||||
return requestedModel
|
||||
}
|
||||
|
||||
kind, _ := auth.AccountInfo()
|
||||
if !strings.EqualFold(strings.TrimSpace(kind), "api_key") {
|
||||
return requestedModel
|
||||
}
|
||||
|
||||
requestedModel = strings.TrimSpace(requestedModel)
|
||||
if requestedModel == "" {
|
||||
return requestedModel
|
||||
}
|
||||
|
||||
// Fast path: lookup per-auth mapping table (keyed by auth.ID).
|
||||
if resolved := m.lookupAPIKeyUpstreamModel(auth.ID, requestedModel); resolved != "" {
|
||||
return resolved
|
||||
}
|
||||
|
||||
// Slow path: scan config for the matching credential entry and resolve alias.
|
||||
// This acts as a safety net if mappings are stale or auth.ID is missing.
|
||||
cfg, _ := m.runtimeConfig.Load().(*internalconfig.Config)
|
||||
if cfg == nil {
|
||||
cfg = &internalconfig.Config{}
|
||||
}
|
||||
|
||||
provider := strings.ToLower(strings.TrimSpace(auth.Provider))
|
||||
upstreamModel := ""
|
||||
switch provider {
|
||||
case "gemini":
|
||||
upstreamModel = resolveUpstreamModelForGeminiAPIKey(cfg, auth, requestedModel)
|
||||
case "claude":
|
||||
upstreamModel = resolveUpstreamModelForClaudeAPIKey(cfg, auth, requestedModel)
|
||||
case "codex":
|
||||
upstreamModel = resolveUpstreamModelForCodexAPIKey(cfg, auth, requestedModel)
|
||||
case "vertex":
|
||||
upstreamModel = resolveUpstreamModelForVertexAPIKey(cfg, auth, requestedModel)
|
||||
default:
|
||||
upstreamModel = resolveUpstreamModelForOpenAICompatAPIKey(cfg, auth, requestedModel)
|
||||
}
|
||||
|
||||
// Return upstream model if found, otherwise return requested model.
|
||||
if upstreamModel != "" {
|
||||
return upstreamModel
|
||||
}
|
||||
return requestedModel
|
||||
}
|
||||
|
||||
// APIKeyConfigEntry is a generic interface for API key configurations.
|
||||
type APIKeyConfigEntry interface {
|
||||
GetAPIKey() string
|
||||
GetBaseURL() string
|
||||
}
|
||||
|
||||
func resolveAPIKeyConfig[T APIKeyConfigEntry](entries []T, auth *Auth) *T {
|
||||
if auth == nil || len(entries) == 0 {
|
||||
return nil
|
||||
}
|
||||
attrKey, attrBase := "", ""
|
||||
if auth.Attributes != nil {
|
||||
attrKey = strings.TrimSpace(auth.Attributes["api_key"])
|
||||
attrBase = strings.TrimSpace(auth.Attributes["base_url"])
|
||||
}
|
||||
for i := range entries {
|
||||
entry := &entries[i]
|
||||
cfgKey := strings.TrimSpace((*entry).GetAPIKey())
|
||||
cfgBase := strings.TrimSpace((*entry).GetBaseURL())
|
||||
if attrKey != "" && attrBase != "" {
|
||||
if strings.EqualFold(cfgKey, attrKey) && strings.EqualFold(cfgBase, attrBase) {
|
||||
return entry
|
||||
}
|
||||
continue
|
||||
}
|
||||
if attrKey != "" && strings.EqualFold(cfgKey, attrKey) {
|
||||
if cfgBase == "" || strings.EqualFold(cfgBase, attrBase) {
|
||||
return entry
|
||||
}
|
||||
}
|
||||
if attrKey == "" && attrBase != "" && strings.EqualFold(cfgBase, attrBase) {
|
||||
return entry
|
||||
}
|
||||
}
|
||||
if attrKey != "" {
|
||||
for i := range entries {
|
||||
entry := &entries[i]
|
||||
if strings.EqualFold(strings.TrimSpace((*entry).GetAPIKey()), attrKey) {
|
||||
return entry
|
||||
}
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func resolveGeminiAPIKeyConfig(cfg *internalconfig.Config, auth *Auth) *internalconfig.GeminiKey {
|
||||
if cfg == nil {
|
||||
return nil
|
||||
}
|
||||
return resolveAPIKeyConfig(cfg.GeminiKey, auth)
|
||||
}
|
||||
|
||||
func resolveClaudeAPIKeyConfig(cfg *internalconfig.Config, auth *Auth) *internalconfig.ClaudeKey {
|
||||
if cfg == nil {
|
||||
return nil
|
||||
}
|
||||
return resolveAPIKeyConfig(cfg.ClaudeKey, auth)
|
||||
}
|
||||
|
||||
func resolveCodexAPIKeyConfig(cfg *internalconfig.Config, auth *Auth) *internalconfig.CodexKey {
|
||||
if cfg == nil {
|
||||
return nil
|
||||
}
|
||||
return resolveAPIKeyConfig(cfg.CodexKey, auth)
|
||||
}
|
||||
|
||||
func resolveVertexAPIKeyConfig(cfg *internalconfig.Config, auth *Auth) *internalconfig.VertexCompatKey {
|
||||
if cfg == nil {
|
||||
return nil
|
||||
}
|
||||
return resolveAPIKeyConfig(cfg.VertexCompatAPIKey, auth)
|
||||
}
|
||||
|
||||
func resolveUpstreamModelForGeminiAPIKey(cfg *internalconfig.Config, auth *Auth, requestedModel string) string {
|
||||
entry := resolveGeminiAPIKeyConfig(cfg, auth)
|
||||
if entry == nil {
|
||||
return ""
|
||||
}
|
||||
return resolveModelAliasFromConfigModels(requestedModel, asModelAliasEntries(entry.Models))
|
||||
}
|
||||
|
||||
func resolveUpstreamModelForClaudeAPIKey(cfg *internalconfig.Config, auth *Auth, requestedModel string) string {
|
||||
entry := resolveClaudeAPIKeyConfig(cfg, auth)
|
||||
if entry == nil {
|
||||
return ""
|
||||
}
|
||||
return resolveModelAliasFromConfigModels(requestedModel, asModelAliasEntries(entry.Models))
|
||||
}
|
||||
|
||||
func resolveUpstreamModelForCodexAPIKey(cfg *internalconfig.Config, auth *Auth, requestedModel string) string {
|
||||
entry := resolveCodexAPIKeyConfig(cfg, auth)
|
||||
if entry == nil {
|
||||
return ""
|
||||
}
|
||||
return resolveModelAliasFromConfigModels(requestedModel, asModelAliasEntries(entry.Models))
|
||||
}
|
||||
|
||||
func resolveUpstreamModelForVertexAPIKey(cfg *internalconfig.Config, auth *Auth, requestedModel string) string {
|
||||
entry := resolveVertexAPIKeyConfig(cfg, auth)
|
||||
if entry == nil {
|
||||
return ""
|
||||
}
|
||||
return resolveModelAliasFromConfigModels(requestedModel, asModelAliasEntries(entry.Models))
|
||||
}
|
||||
|
||||
func resolveUpstreamModelForOpenAICompatAPIKey(cfg *internalconfig.Config, auth *Auth, requestedModel string) string {
|
||||
providerKey := ""
|
||||
compatName := ""
|
||||
if auth != nil && len(auth.Attributes) > 0 {
|
||||
providerKey = strings.TrimSpace(auth.Attributes["provider_key"])
|
||||
compatName = strings.TrimSpace(auth.Attributes["compat_name"])
|
||||
}
|
||||
if compatName == "" && !strings.EqualFold(strings.TrimSpace(auth.Provider), "openai-compatibility") {
|
||||
return ""
|
||||
}
|
||||
entry := resolveOpenAICompatConfig(cfg, providerKey, compatName, auth.Provider)
|
||||
if entry == nil {
|
||||
return ""
|
||||
}
|
||||
return resolveModelAliasFromConfigModels(requestedModel, asModelAliasEntries(entry.Models))
|
||||
}
|
||||
|
||||
type apiKeyModelAliasTable map[string]map[string]string
|
||||
|
||||
func resolveOpenAICompatConfig(cfg *internalconfig.Config, providerKey, compatName, authProvider string) *internalconfig.OpenAICompatibility {
|
||||
if cfg == nil {
|
||||
return nil
|
||||
}
|
||||
candidates := make([]string, 0, 3)
|
||||
if v := strings.TrimSpace(compatName); v != "" {
|
||||
candidates = append(candidates, v)
|
||||
}
|
||||
if v := strings.TrimSpace(providerKey); v != "" {
|
||||
candidates = append(candidates, v)
|
||||
}
|
||||
if v := strings.TrimSpace(authProvider); v != "" {
|
||||
candidates = append(candidates, v)
|
||||
}
|
||||
for i := range cfg.OpenAICompatibility {
|
||||
compat := &cfg.OpenAICompatibility[i]
|
||||
for _, candidate := range candidates {
|
||||
if candidate != "" && strings.EqualFold(strings.TrimSpace(candidate), compat.Name) {
|
||||
return compat
|
||||
}
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func asModelAliasEntries[T interface {
|
||||
GetName() string
|
||||
GetAlias() string
|
||||
}](models []T) []modelAliasEntry {
|
||||
if len(models) == 0 {
|
||||
return nil
|
||||
}
|
||||
out := make([]modelAliasEntry, 0, len(models))
|
||||
for i := range models {
|
||||
out = append(out, models[i])
|
||||
}
|
||||
return out
|
||||
}
|
||||
|
||||
func (m *Manager) normalizeProviders(providers []string) []string {
|
||||
if len(providers) == 0 {
|
||||
return nil
|
||||
@@ -1729,392 +1351,6 @@ func (m *Manager) persist(ctx context.Context, auth *Auth) error {
|
||||
return err
|
||||
}
|
||||
|
||||
// StartAutoRefresh launches a background loop that evaluates auth freshness
|
||||
// every few seconds and triggers refresh operations when required.
|
||||
// Only one loop is kept alive; starting a new one cancels the previous run.
|
||||
func (m *Manager) StartAutoRefresh(parent context.Context, interval time.Duration) {
|
||||
if interval <= 0 || interval > refreshCheckInterval {
|
||||
interval = refreshCheckInterval
|
||||
} else {
|
||||
interval = refreshCheckInterval
|
||||
}
|
||||
if m.refreshCancel != nil {
|
||||
m.refreshCancel()
|
||||
m.refreshCancel = nil
|
||||
}
|
||||
ctx, cancel := context.WithCancel(parent)
|
||||
m.refreshCancel = cancel
|
||||
go func() {
|
||||
ticker := time.NewTicker(interval)
|
||||
defer ticker.Stop()
|
||||
m.checkRefreshes(ctx)
|
||||
for {
|
||||
select {
|
||||
case <-ctx.Done():
|
||||
return
|
||||
case <-ticker.C:
|
||||
m.checkRefreshes(ctx)
|
||||
}
|
||||
}
|
||||
}()
|
||||
}
|
||||
|
||||
// StopAutoRefresh cancels the background refresh loop, if running.
|
||||
func (m *Manager) StopAutoRefresh() {
|
||||
if m.refreshCancel != nil {
|
||||
m.refreshCancel()
|
||||
m.refreshCancel = nil
|
||||
}
|
||||
}
|
||||
|
||||
func (m *Manager) checkRefreshes(ctx context.Context) {
|
||||
// log.Debugf("checking refreshes")
|
||||
now := time.Now()
|
||||
snapshot := m.snapshotAuths()
|
||||
for _, a := range snapshot {
|
||||
typ, _ := a.AccountInfo()
|
||||
if typ != "api_key" {
|
||||
if !m.shouldRefresh(a, now) {
|
||||
continue
|
||||
}
|
||||
log.Debugf("checking refresh for %s, %s, %s", a.Provider, a.ID, typ)
|
||||
|
||||
if exec := m.executorFor(a.Provider); exec == nil {
|
||||
continue
|
||||
}
|
||||
if !m.markRefreshPending(a.ID, now) {
|
||||
continue
|
||||
}
|
||||
go m.refreshAuth(ctx, a.ID)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func (m *Manager) snapshotAuths() []*Auth {
|
||||
m.mu.RLock()
|
||||
defer m.mu.RUnlock()
|
||||
out := make([]*Auth, 0, len(m.auths))
|
||||
for _, a := range m.auths {
|
||||
out = append(out, a.Clone())
|
||||
}
|
||||
return out
|
||||
}
|
||||
|
||||
func (m *Manager) shouldRefresh(a *Auth, now time.Time) bool {
|
||||
if a == nil || a.Disabled {
|
||||
return false
|
||||
}
|
||||
if !a.NextRefreshAfter.IsZero() && now.Before(a.NextRefreshAfter) {
|
||||
return false
|
||||
}
|
||||
if evaluator, ok := a.Runtime.(RefreshEvaluator); ok && evaluator != nil {
|
||||
return evaluator.ShouldRefresh(now, a)
|
||||
}
|
||||
|
||||
lastRefresh := a.LastRefreshedAt
|
||||
if lastRefresh.IsZero() {
|
||||
if ts, ok := authLastRefreshTimestamp(a); ok {
|
||||
lastRefresh = ts
|
||||
}
|
||||
}
|
||||
|
||||
expiry, hasExpiry := a.ExpirationTime()
|
||||
|
||||
if interval := authPreferredInterval(a); interval > 0 {
|
||||
if hasExpiry && !expiry.IsZero() {
|
||||
if !expiry.After(now) {
|
||||
return true
|
||||
}
|
||||
if expiry.Sub(now) <= interval {
|
||||
return true
|
||||
}
|
||||
}
|
||||
if lastRefresh.IsZero() {
|
||||
return true
|
||||
}
|
||||
return now.Sub(lastRefresh) >= interval
|
||||
}
|
||||
|
||||
provider := strings.ToLower(a.Provider)
|
||||
lead := ProviderRefreshLead(provider, a.Runtime)
|
||||
if lead == nil {
|
||||
return false
|
||||
}
|
||||
if *lead <= 0 {
|
||||
if hasExpiry && !expiry.IsZero() {
|
||||
return now.After(expiry)
|
||||
}
|
||||
return false
|
||||
}
|
||||
if hasExpiry && !expiry.IsZero() {
|
||||
return time.Until(expiry) <= *lead
|
||||
}
|
||||
if !lastRefresh.IsZero() {
|
||||
return now.Sub(lastRefresh) >= *lead
|
||||
}
|
||||
return true
|
||||
}
|
||||
|
||||
func authPreferredInterval(a *Auth) time.Duration {
|
||||
if a == nil {
|
||||
return 0
|
||||
}
|
||||
if d := durationFromMetadata(a.Metadata, "refresh_interval_seconds", "refreshIntervalSeconds", "refresh_interval", "refreshInterval"); d > 0 {
|
||||
return d
|
||||
}
|
||||
if d := durationFromAttributes(a.Attributes, "refresh_interval_seconds", "refreshIntervalSeconds", "refresh_interval", "refreshInterval"); d > 0 {
|
||||
return d
|
||||
}
|
||||
return 0
|
||||
}
|
||||
|
||||
func durationFromMetadata(meta map[string]any, keys ...string) time.Duration {
|
||||
if len(meta) == 0 {
|
||||
return 0
|
||||
}
|
||||
for _, key := range keys {
|
||||
if val, ok := meta[key]; ok {
|
||||
if dur := parseDurationValue(val); dur > 0 {
|
||||
return dur
|
||||
}
|
||||
}
|
||||
}
|
||||
return 0
|
||||
}
|
||||
|
||||
func durationFromAttributes(attrs map[string]string, keys ...string) time.Duration {
|
||||
if len(attrs) == 0 {
|
||||
return 0
|
||||
}
|
||||
for _, key := range keys {
|
||||
if val, ok := attrs[key]; ok {
|
||||
if dur := parseDurationString(val); dur > 0 {
|
||||
return dur
|
||||
}
|
||||
}
|
||||
}
|
||||
return 0
|
||||
}
|
||||
|
||||
func parseDurationValue(val any) time.Duration {
|
||||
switch v := val.(type) {
|
||||
case time.Duration:
|
||||
if v <= 0 {
|
||||
return 0
|
||||
}
|
||||
return v
|
||||
case int:
|
||||
if v <= 0 {
|
||||
return 0
|
||||
}
|
||||
return time.Duration(v) * time.Second
|
||||
case int32:
|
||||
if v <= 0 {
|
||||
return 0
|
||||
}
|
||||
return time.Duration(v) * time.Second
|
||||
case int64:
|
||||
if v <= 0 {
|
||||
return 0
|
||||
}
|
||||
return time.Duration(v) * time.Second
|
||||
case uint:
|
||||
if v == 0 {
|
||||
return 0
|
||||
}
|
||||
return time.Duration(v) * time.Second
|
||||
case uint32:
|
||||
if v == 0 {
|
||||
return 0
|
||||
}
|
||||
return time.Duration(v) * time.Second
|
||||
case uint64:
|
||||
if v == 0 {
|
||||
return 0
|
||||
}
|
||||
return time.Duration(v) * time.Second
|
||||
case float32:
|
||||
if v <= 0 {
|
||||
return 0
|
||||
}
|
||||
return time.Duration(float64(v) * float64(time.Second))
|
||||
case float64:
|
||||
if v <= 0 {
|
||||
return 0
|
||||
}
|
||||
return time.Duration(v * float64(time.Second))
|
||||
case json.Number:
|
||||
if i, err := v.Int64(); err == nil {
|
||||
if i <= 0 {
|
||||
return 0
|
||||
}
|
||||
return time.Duration(i) * time.Second
|
||||
}
|
||||
if f, err := v.Float64(); err == nil && f > 0 {
|
||||
return time.Duration(f * float64(time.Second))
|
||||
}
|
||||
case string:
|
||||
return parseDurationString(v)
|
||||
}
|
||||
return 0
|
||||
}
|
||||
|
||||
func parseDurationString(raw string) time.Duration {
|
||||
s := strings.TrimSpace(raw)
|
||||
if s == "" {
|
||||
return 0
|
||||
}
|
||||
if dur, err := time.ParseDuration(s); err == nil && dur > 0 {
|
||||
return dur
|
||||
}
|
||||
if secs, err := strconv.ParseFloat(s, 64); err == nil && secs > 0 {
|
||||
return time.Duration(secs * float64(time.Second))
|
||||
}
|
||||
return 0
|
||||
}
|
||||
|
||||
func authLastRefreshTimestamp(a *Auth) (time.Time, bool) {
|
||||
if a == nil {
|
||||
return time.Time{}, false
|
||||
}
|
||||
if a.Metadata != nil {
|
||||
if ts, ok := lookupMetadataTime(a.Metadata, "last_refresh", "lastRefresh", "last_refreshed_at", "lastRefreshedAt"); ok {
|
||||
return ts, true
|
||||
}
|
||||
}
|
||||
if a.Attributes != nil {
|
||||
for _, key := range []string{"last_refresh", "lastRefresh", "last_refreshed_at", "lastRefreshedAt"} {
|
||||
if val := strings.TrimSpace(a.Attributes[key]); val != "" {
|
||||
if ts, ok := parseTimeValue(val); ok {
|
||||
return ts, true
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return time.Time{}, false
|
||||
}
|
||||
|
||||
func lookupMetadataTime(meta map[string]any, keys ...string) (time.Time, bool) {
|
||||
for _, key := range keys {
|
||||
if val, ok := meta[key]; ok {
|
||||
if ts, ok1 := parseTimeValue(val); ok1 {
|
||||
return ts, true
|
||||
}
|
||||
}
|
||||
}
|
||||
return time.Time{}, false
|
||||
}
|
||||
|
||||
func (m *Manager) markRefreshPending(id string, now time.Time) bool {
|
||||
m.mu.Lock()
|
||||
defer m.mu.Unlock()
|
||||
auth, ok := m.auths[id]
|
||||
if !ok || auth == nil || auth.Disabled {
|
||||
return false
|
||||
}
|
||||
if !auth.NextRefreshAfter.IsZero() && now.Before(auth.NextRefreshAfter) {
|
||||
return false
|
||||
}
|
||||
auth.NextRefreshAfter = now.Add(refreshPendingBackoff)
|
||||
m.auths[id] = auth
|
||||
return true
|
||||
}
|
||||
|
||||
func (m *Manager) refreshAuth(ctx context.Context, id string) {
|
||||
if ctx == nil {
|
||||
ctx = context.Background()
|
||||
}
|
||||
m.mu.RLock()
|
||||
auth := m.auths[id]
|
||||
var exec ProviderExecutor
|
||||
if auth != nil {
|
||||
exec = m.executors[auth.Provider]
|
||||
}
|
||||
m.mu.RUnlock()
|
||||
if auth == nil || exec == nil {
|
||||
return
|
||||
}
|
||||
cloned := auth.Clone()
|
||||
updated, err := exec.Refresh(ctx, cloned)
|
||||
if err != nil && errors.Is(err, context.Canceled) {
|
||||
log.Debugf("refresh canceled for %s, %s", auth.Provider, auth.ID)
|
||||
return
|
||||
}
|
||||
log.Debugf("refreshed %s, %s, %v", auth.Provider, auth.ID, err)
|
||||
now := time.Now()
|
||||
if err != nil {
|
||||
m.mu.Lock()
|
||||
if current := m.auths[id]; current != nil {
|
||||
current.NextRefreshAfter = now.Add(refreshFailureBackoff)
|
||||
current.LastError = &Error{Message: err.Error()}
|
||||
m.auths[id] = current
|
||||
}
|
||||
m.mu.Unlock()
|
||||
return
|
||||
}
|
||||
if updated == nil {
|
||||
updated = cloned
|
||||
}
|
||||
// Preserve runtime created by the executor during Refresh.
|
||||
// If executor didn't set one, fall back to the previous runtime.
|
||||
if updated.Runtime == nil {
|
||||
updated.Runtime = auth.Runtime
|
||||
}
|
||||
updated.LastRefreshedAt = now
|
||||
updated.NextRefreshAfter = time.Time{}
|
||||
updated.LastError = nil
|
||||
updated.UpdatedAt = now
|
||||
_, _ = m.Update(ctx, updated)
|
||||
}
|
||||
|
||||
func (m *Manager) executorFor(provider string) ProviderExecutor {
|
||||
m.mu.RLock()
|
||||
defer m.mu.RUnlock()
|
||||
return m.executors[provider]
|
||||
}
|
||||
|
||||
// roundTripperContextKey is an unexported context key type to avoid collisions.
|
||||
type roundTripperContextKey struct{}
|
||||
|
||||
// roundTripperFor retrieves an HTTP RoundTripper for the given auth if a provider is registered.
|
||||
func (m *Manager) roundTripperFor(auth *Auth) http.RoundTripper {
|
||||
m.mu.RLock()
|
||||
p := m.rtProvider
|
||||
m.mu.RUnlock()
|
||||
if p == nil || auth == nil {
|
||||
return nil
|
||||
}
|
||||
return p.RoundTripperFor(auth)
|
||||
}
|
||||
|
||||
// RoundTripperProvider defines a minimal provider of per-auth HTTP transports.
|
||||
type RoundTripperProvider interface {
|
||||
RoundTripperFor(auth *Auth) http.RoundTripper
|
||||
}
|
||||
|
||||
// RequestPreparer is an optional interface that provider executors can implement
|
||||
// to mutate outbound HTTP requests with provider credentials.
|
||||
type RequestPreparer interface {
|
||||
PrepareRequest(req *http.Request, auth *Auth) error
|
||||
}
|
||||
|
||||
func executorKeyFromAuth(auth *Auth) string {
|
||||
if auth == nil {
|
||||
return ""
|
||||
}
|
||||
if auth.Attributes != nil {
|
||||
providerKey := strings.TrimSpace(auth.Attributes["provider_key"])
|
||||
compatName := strings.TrimSpace(auth.Attributes["compat_name"])
|
||||
if compatName != "" {
|
||||
if providerKey == "" {
|
||||
providerKey = compatName
|
||||
}
|
||||
return strings.ToLower(providerKey)
|
||||
}
|
||||
}
|
||||
return strings.ToLower(strings.TrimSpace(auth.Provider))
|
||||
}
|
||||
|
||||
// logEntryWithRequestID returns a logrus entry with request_id field if available in context.
|
||||
func logEntryWithRequestID(ctx context.Context) *log.Entry {
|
||||
if ctx == nil {
|
||||
@@ -2178,103 +1414,3 @@ func formatOauthIdentity(auth *Auth, provider string, accountInfo string) string
|
||||
}
|
||||
return strings.Join(parts, " ")
|
||||
}
|
||||
|
||||
// InjectCredentials delegates per-provider HTTP request preparation when supported.
|
||||
// If the registered executor for the auth provider implements RequestPreparer,
|
||||
// it will be invoked to modify the request (e.g., add headers).
|
||||
func (m *Manager) InjectCredentials(req *http.Request, authID string) error {
|
||||
if req == nil || authID == "" {
|
||||
return nil
|
||||
}
|
||||
m.mu.RLock()
|
||||
a := m.auths[authID]
|
||||
var exec ProviderExecutor
|
||||
if a != nil {
|
||||
exec = m.executors[executorKeyFromAuth(a)]
|
||||
}
|
||||
m.mu.RUnlock()
|
||||
if a == nil || exec == nil {
|
||||
return nil
|
||||
}
|
||||
if p, ok := exec.(RequestPreparer); ok && p != nil {
|
||||
return p.PrepareRequest(req, a)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// PrepareHttpRequest injects provider credentials into the supplied HTTP request.
|
||||
func (m *Manager) PrepareHttpRequest(ctx context.Context, auth *Auth, req *http.Request) error {
|
||||
if m == nil {
|
||||
return &Error{Code: "provider_not_found", Message: "manager is nil"}
|
||||
}
|
||||
if auth == nil {
|
||||
return &Error{Code: "auth_not_found", Message: "auth is nil"}
|
||||
}
|
||||
if req == nil {
|
||||
return &Error{Code: "invalid_request", Message: "http request is nil"}
|
||||
}
|
||||
if ctx != nil {
|
||||
*req = *req.WithContext(ctx)
|
||||
}
|
||||
providerKey := executorKeyFromAuth(auth)
|
||||
if providerKey == "" {
|
||||
return &Error{Code: "provider_not_found", Message: "auth provider is empty"}
|
||||
}
|
||||
exec := m.executorFor(providerKey)
|
||||
if exec == nil {
|
||||
return &Error{Code: "provider_not_found", Message: "executor not registered for provider: " + providerKey}
|
||||
}
|
||||
preparer, ok := exec.(RequestPreparer)
|
||||
if !ok || preparer == nil {
|
||||
return &Error{Code: "not_supported", Message: "executor does not support http request preparation"}
|
||||
}
|
||||
return preparer.PrepareRequest(req, auth)
|
||||
}
|
||||
|
||||
// NewHttpRequest constructs a new HTTP request and injects provider credentials into it.
|
||||
func (m *Manager) NewHttpRequest(ctx context.Context, auth *Auth, method, targetURL string, body []byte, headers http.Header) (*http.Request, error) {
|
||||
if ctx == nil {
|
||||
ctx = context.Background()
|
||||
}
|
||||
method = strings.TrimSpace(method)
|
||||
if method == "" {
|
||||
method = http.MethodGet
|
||||
}
|
||||
var reader io.Reader
|
||||
if body != nil {
|
||||
reader = bytes.NewReader(body)
|
||||
}
|
||||
httpReq, err := http.NewRequestWithContext(ctx, method, targetURL, reader)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if headers != nil {
|
||||
httpReq.Header = headers.Clone()
|
||||
}
|
||||
if errPrepare := m.PrepareHttpRequest(ctx, auth, httpReq); errPrepare != nil {
|
||||
return nil, errPrepare
|
||||
}
|
||||
return httpReq, nil
|
||||
}
|
||||
|
||||
// HttpRequest injects provider credentials into the supplied HTTP request and executes it.
|
||||
func (m *Manager) HttpRequest(ctx context.Context, auth *Auth, req *http.Request) (*http.Response, error) {
|
||||
if m == nil {
|
||||
return nil, &Error{Code: "provider_not_found", Message: "manager is nil"}
|
||||
}
|
||||
if auth == nil {
|
||||
return nil, &Error{Code: "auth_not_found", Message: "auth is nil"}
|
||||
}
|
||||
if req == nil {
|
||||
return nil, &Error{Code: "invalid_request", Message: "http request is nil"}
|
||||
}
|
||||
providerKey := executorKeyFromAuth(auth)
|
||||
if providerKey == "" {
|
||||
return nil, &Error{Code: "provider_not_found", Message: "auth provider is empty"}
|
||||
}
|
||||
exec := m.executorFor(providerKey)
|
||||
if exec == nil {
|
||||
return nil, &Error{Code: "provider_not_found", Message: "executor not registered for provider: " + providerKey}
|
||||
}
|
||||
return exec.HttpRequest(ctx, auth, req)
|
||||
}
|
||||
|
||||
@@ -0,0 +1,383 @@
|
||||
package auth
|
||||
|
||||
import (
|
||||
"strings"
|
||||
|
||||
internalconfig "github.com/router-for-me/CLIProxyAPI/v6/internal/config"
|
||||
"github.com/router-for-me/CLIProxyAPI/v6/internal/thinking"
|
||||
)
|
||||
|
||||
// apiKeyModelAliasTable maps auth ID to alias->upstream model mappings.
|
||||
type apiKeyModelAliasTable map[string]map[string]string
|
||||
|
||||
func (m *Manager) lookupAPIKeyUpstreamModel(authID, requestedModel string) string {
|
||||
if m == nil {
|
||||
return ""
|
||||
}
|
||||
authID = strings.TrimSpace(authID)
|
||||
if authID == "" {
|
||||
return ""
|
||||
}
|
||||
requestedModel = strings.TrimSpace(requestedModel)
|
||||
if requestedModel == "" {
|
||||
return ""
|
||||
}
|
||||
table, _ := m.apiKeyModelAlias.Load().(apiKeyModelAliasTable)
|
||||
if table == nil {
|
||||
return ""
|
||||
}
|
||||
byAlias := table[authID]
|
||||
if len(byAlias) == 0 {
|
||||
return ""
|
||||
}
|
||||
key := strings.ToLower(thinking.ParseSuffix(requestedModel).ModelName)
|
||||
if key == "" {
|
||||
key = strings.ToLower(requestedModel)
|
||||
}
|
||||
resolved := strings.TrimSpace(byAlias[key])
|
||||
if resolved == "" {
|
||||
return ""
|
||||
}
|
||||
// Preserve thinking suffix from the client's requested model unless config already has one.
|
||||
requestResult := thinking.ParseSuffix(requestedModel)
|
||||
if thinking.ParseSuffix(resolved).HasSuffix {
|
||||
return resolved
|
||||
}
|
||||
if requestResult.HasSuffix && requestResult.RawSuffix != "" {
|
||||
return resolved + "(" + requestResult.RawSuffix + ")"
|
||||
}
|
||||
return resolved
|
||||
|
||||
}
|
||||
|
||||
func (m *Manager) rebuildAPIKeyModelAliasFromRuntimeConfig() {
|
||||
if m == nil {
|
||||
return
|
||||
}
|
||||
cfg, _ := m.runtimeConfig.Load().(*internalconfig.Config)
|
||||
if cfg == nil {
|
||||
cfg = &internalconfig.Config{}
|
||||
}
|
||||
m.mu.Lock()
|
||||
defer m.mu.Unlock()
|
||||
m.rebuildAPIKeyModelAliasLocked(cfg)
|
||||
}
|
||||
|
||||
func (m *Manager) rebuildAPIKeyModelAliasLocked(cfg *internalconfig.Config) {
|
||||
if m == nil {
|
||||
return
|
||||
}
|
||||
if cfg == nil {
|
||||
cfg = &internalconfig.Config{}
|
||||
}
|
||||
|
||||
out := make(apiKeyModelAliasTable)
|
||||
for _, auth := range m.auths {
|
||||
if auth == nil {
|
||||
continue
|
||||
}
|
||||
if strings.TrimSpace(auth.ID) == "" {
|
||||
continue
|
||||
}
|
||||
kind, _ := auth.AccountInfo()
|
||||
if !strings.EqualFold(strings.TrimSpace(kind), "api_key") {
|
||||
continue
|
||||
}
|
||||
|
||||
byAlias := make(map[string]string)
|
||||
provider := strings.ToLower(strings.TrimSpace(auth.Provider))
|
||||
switch provider {
|
||||
case "gemini":
|
||||
if entry := resolveGeminiAPIKeyConfig(cfg, auth); entry != nil {
|
||||
compileAPIKeyModelAliasForModels(byAlias, entry.Models)
|
||||
}
|
||||
case "claude":
|
||||
if entry := resolveClaudeAPIKeyConfig(cfg, auth); entry != nil {
|
||||
compileAPIKeyModelAliasForModels(byAlias, entry.Models)
|
||||
}
|
||||
case "codex":
|
||||
if entry := resolveCodexAPIKeyConfig(cfg, auth); entry != nil {
|
||||
compileAPIKeyModelAliasForModels(byAlias, entry.Models)
|
||||
}
|
||||
case "vertex":
|
||||
if entry := resolveVertexAPIKeyConfig(cfg, auth); entry != nil {
|
||||
compileAPIKeyModelAliasForModels(byAlias, entry.Models)
|
||||
}
|
||||
default:
|
||||
// OpenAI-compat uses config selection from auth.Attributes.
|
||||
providerKey := ""
|
||||
compatName := ""
|
||||
if auth.Attributes != nil {
|
||||
providerKey = strings.TrimSpace(auth.Attributes["provider_key"])
|
||||
compatName = strings.TrimSpace(auth.Attributes["compat_name"])
|
||||
}
|
||||
if compatName != "" || strings.EqualFold(strings.TrimSpace(auth.Provider), "openai-compatibility") {
|
||||
if entry := resolveOpenAICompatConfig(cfg, providerKey, compatName, auth.Provider); entry != nil {
|
||||
compileAPIKeyModelAliasForModels(byAlias, entry.Models)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if len(byAlias) > 0 {
|
||||
out[auth.ID] = byAlias
|
||||
}
|
||||
}
|
||||
|
||||
m.apiKeyModelAlias.Store(out)
|
||||
}
|
||||
|
||||
func compileAPIKeyModelAliasForModels[T interface {
|
||||
GetName() string
|
||||
GetAlias() string
|
||||
}](out map[string]string, models []T) {
|
||||
if out == nil {
|
||||
return
|
||||
}
|
||||
for i := range models {
|
||||
alias := strings.TrimSpace(models[i].GetAlias())
|
||||
name := strings.TrimSpace(models[i].GetName())
|
||||
if alias == "" || name == "" {
|
||||
continue
|
||||
}
|
||||
aliasKey := strings.ToLower(thinking.ParseSuffix(alias).ModelName)
|
||||
if aliasKey == "" {
|
||||
aliasKey = strings.ToLower(alias)
|
||||
}
|
||||
// Config priority: first alias wins.
|
||||
if _, exists := out[aliasKey]; exists {
|
||||
continue
|
||||
}
|
||||
out[aliasKey] = name
|
||||
// Also allow direct lookup by upstream name (case-insensitive), so lookups on already-upstream
|
||||
// models remain a cheap no-op.
|
||||
nameKey := strings.ToLower(thinking.ParseSuffix(name).ModelName)
|
||||
if nameKey == "" {
|
||||
nameKey = strings.ToLower(name)
|
||||
}
|
||||
if nameKey != "" {
|
||||
if _, exists := out[nameKey]; !exists {
|
||||
out[nameKey] = name
|
||||
}
|
||||
}
|
||||
// Preserve config suffix priority by seeding a base-name lookup when name already has suffix.
|
||||
nameResult := thinking.ParseSuffix(name)
|
||||
if nameResult.HasSuffix {
|
||||
baseKey := strings.ToLower(strings.TrimSpace(nameResult.ModelName))
|
||||
if baseKey != "" {
|
||||
if _, exists := out[baseKey]; !exists {
|
||||
out[baseKey] = name
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func (m *Manager) applyAPIKeyModelAlias(auth *Auth, requestedModel string) string {
|
||||
if m == nil || auth == nil {
|
||||
return requestedModel
|
||||
}
|
||||
|
||||
kind, _ := auth.AccountInfo()
|
||||
if !strings.EqualFold(strings.TrimSpace(kind), "api_key") {
|
||||
return requestedModel
|
||||
}
|
||||
|
||||
requestedModel = strings.TrimSpace(requestedModel)
|
||||
if requestedModel == "" {
|
||||
return requestedModel
|
||||
}
|
||||
|
||||
// Fast path: lookup per-auth mapping table (keyed by auth.ID).
|
||||
if resolved := m.lookupAPIKeyUpstreamModel(auth.ID, requestedModel); resolved != "" {
|
||||
return resolved
|
||||
}
|
||||
|
||||
// Slow path: scan config for the matching credential entry and resolve alias.
|
||||
// This acts as a safety net if mappings are stale or auth.ID is missing.
|
||||
cfg, _ := m.runtimeConfig.Load().(*internalconfig.Config)
|
||||
if cfg == nil {
|
||||
cfg = &internalconfig.Config{}
|
||||
}
|
||||
|
||||
provider := strings.ToLower(strings.TrimSpace(auth.Provider))
|
||||
upstreamModel := ""
|
||||
switch provider {
|
||||
case "gemini":
|
||||
upstreamModel = resolveUpstreamModelForGeminiAPIKey(cfg, auth, requestedModel)
|
||||
case "claude":
|
||||
upstreamModel = resolveUpstreamModelForClaudeAPIKey(cfg, auth, requestedModel)
|
||||
case "codex":
|
||||
upstreamModel = resolveUpstreamModelForCodexAPIKey(cfg, auth, requestedModel)
|
||||
case "vertex":
|
||||
upstreamModel = resolveUpstreamModelForVertexAPIKey(cfg, auth, requestedModel)
|
||||
default:
|
||||
upstreamModel = resolveUpstreamModelForOpenAICompatAPIKey(cfg, auth, requestedModel)
|
||||
}
|
||||
|
||||
// Return upstream model if found, otherwise return requested model.
|
||||
if upstreamModel != "" {
|
||||
return upstreamModel
|
||||
}
|
||||
return requestedModel
|
||||
}
|
||||
|
||||
// APIKeyConfigEntry is a generic interface for API key configurations.
|
||||
type APIKeyConfigEntry interface {
|
||||
GetAPIKey() string
|
||||
GetBaseURL() string
|
||||
}
|
||||
|
||||
func resolveAPIKeyConfig[T APIKeyConfigEntry](entries []T, auth *Auth) *T {
|
||||
if auth == nil || len(entries) == 0 {
|
||||
return nil
|
||||
}
|
||||
attrKey, attrBase := "", ""
|
||||
if auth.Attributes != nil {
|
||||
attrKey = strings.TrimSpace(auth.Attributes["api_key"])
|
||||
attrBase = strings.TrimSpace(auth.Attributes["base_url"])
|
||||
}
|
||||
for i := range entries {
|
||||
entry := &entries[i]
|
||||
cfgKey := strings.TrimSpace((*entry).GetAPIKey())
|
||||
cfgBase := strings.TrimSpace((*entry).GetBaseURL())
|
||||
if attrKey != "" && attrBase != "" {
|
||||
if strings.EqualFold(cfgKey, attrKey) && strings.EqualFold(cfgBase, attrBase) {
|
||||
return entry
|
||||
}
|
||||
continue
|
||||
}
|
||||
if attrKey != "" && strings.EqualFold(cfgKey, attrKey) {
|
||||
if cfgBase == "" || strings.EqualFold(cfgBase, attrBase) {
|
||||
return entry
|
||||
}
|
||||
}
|
||||
if attrKey == "" && attrBase != "" && strings.EqualFold(cfgBase, attrBase) {
|
||||
return entry
|
||||
}
|
||||
}
|
||||
if attrKey != "" {
|
||||
for i := range entries {
|
||||
entry := &entries[i]
|
||||
if strings.EqualFold(strings.TrimSpace((*entry).GetAPIKey()), attrKey) {
|
||||
return entry
|
||||
}
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func resolveGeminiAPIKeyConfig(cfg *internalconfig.Config, auth *Auth) *internalconfig.GeminiKey {
|
||||
if cfg == nil {
|
||||
return nil
|
||||
}
|
||||
return resolveAPIKeyConfig(cfg.GeminiKey, auth)
|
||||
}
|
||||
|
||||
func resolveClaudeAPIKeyConfig(cfg *internalconfig.Config, auth *Auth) *internalconfig.ClaudeKey {
|
||||
if cfg == nil {
|
||||
return nil
|
||||
}
|
||||
return resolveAPIKeyConfig(cfg.ClaudeKey, auth)
|
||||
}
|
||||
|
||||
func resolveCodexAPIKeyConfig(cfg *internalconfig.Config, auth *Auth) *internalconfig.CodexKey {
|
||||
if cfg == nil {
|
||||
return nil
|
||||
}
|
||||
return resolveAPIKeyConfig(cfg.CodexKey, auth)
|
||||
}
|
||||
|
||||
func resolveVertexAPIKeyConfig(cfg *internalconfig.Config, auth *Auth) *internalconfig.VertexCompatKey {
|
||||
if cfg == nil {
|
||||
return nil
|
||||
}
|
||||
return resolveAPIKeyConfig(cfg.VertexCompatAPIKey, auth)
|
||||
}
|
||||
|
||||
func resolveUpstreamModelForGeminiAPIKey(cfg *internalconfig.Config, auth *Auth, requestedModel string) string {
|
||||
entry := resolveGeminiAPIKeyConfig(cfg, auth)
|
||||
if entry == nil {
|
||||
return ""
|
||||
}
|
||||
return resolveModelAliasFromConfigModels(requestedModel, asModelAliasEntries(entry.Models))
|
||||
}
|
||||
|
||||
func resolveUpstreamModelForClaudeAPIKey(cfg *internalconfig.Config, auth *Auth, requestedModel string) string {
|
||||
entry := resolveClaudeAPIKeyConfig(cfg, auth)
|
||||
if entry == nil {
|
||||
return ""
|
||||
}
|
||||
return resolveModelAliasFromConfigModels(requestedModel, asModelAliasEntries(entry.Models))
|
||||
}
|
||||
|
||||
func resolveUpstreamModelForCodexAPIKey(cfg *internalconfig.Config, auth *Auth, requestedModel string) string {
|
||||
entry := resolveCodexAPIKeyConfig(cfg, auth)
|
||||
if entry == nil {
|
||||
return ""
|
||||
}
|
||||
return resolveModelAliasFromConfigModels(requestedModel, asModelAliasEntries(entry.Models))
|
||||
}
|
||||
|
||||
func resolveUpstreamModelForVertexAPIKey(cfg *internalconfig.Config, auth *Auth, requestedModel string) string {
|
||||
entry := resolveVertexAPIKeyConfig(cfg, auth)
|
||||
if entry == nil {
|
||||
return ""
|
||||
}
|
||||
return resolveModelAliasFromConfigModels(requestedModel, asModelAliasEntries(entry.Models))
|
||||
}
|
||||
|
||||
func resolveUpstreamModelForOpenAICompatAPIKey(cfg *internalconfig.Config, auth *Auth, requestedModel string) string {
|
||||
providerKey := ""
|
||||
compatName := ""
|
||||
if auth != nil && len(auth.Attributes) > 0 {
|
||||
providerKey = strings.TrimSpace(auth.Attributes["provider_key"])
|
||||
compatName = strings.TrimSpace(auth.Attributes["compat_name"])
|
||||
}
|
||||
if compatName == "" && !strings.EqualFold(strings.TrimSpace(auth.Provider), "openai-compatibility") {
|
||||
return ""
|
||||
}
|
||||
entry := resolveOpenAICompatConfig(cfg, providerKey, compatName, auth.Provider)
|
||||
if entry == nil {
|
||||
return ""
|
||||
}
|
||||
return resolveModelAliasFromConfigModels(requestedModel, asModelAliasEntries(entry.Models))
|
||||
}
|
||||
|
||||
func resolveOpenAICompatConfig(cfg *internalconfig.Config, providerKey, compatName, authProvider string) *internalconfig.OpenAICompatibility {
|
||||
if cfg == nil {
|
||||
return nil
|
||||
}
|
||||
candidates := make([]string, 0, 3)
|
||||
if v := strings.TrimSpace(compatName); v != "" {
|
||||
candidates = append(candidates, v)
|
||||
}
|
||||
if v := strings.TrimSpace(providerKey); v != "" {
|
||||
candidates = append(candidates, v)
|
||||
}
|
||||
if v := strings.TrimSpace(authProvider); v != "" {
|
||||
candidates = append(candidates, v)
|
||||
}
|
||||
for i := range cfg.OpenAICompatibility {
|
||||
compat := &cfg.OpenAICompatibility[i]
|
||||
for _, candidate := range candidates {
|
||||
if candidate != "" && strings.EqualFold(strings.TrimSpace(candidate), compat.Name) {
|
||||
return compat
|
||||
}
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func asModelAliasEntries[T interface {
|
||||
GetName() string
|
||||
GetAlias() string
|
||||
}](models []T) []modelAliasEntry {
|
||||
if len(models) == 0 {
|
||||
return nil
|
||||
}
|
||||
out := make([]modelAliasEntry, 0, len(models))
|
||||
for i := range models {
|
||||
out = append(out, models[i])
|
||||
}
|
||||
return out
|
||||
}
|
||||
@@ -0,0 +1,501 @@
|
||||
package auth
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"context"
|
||||
"encoding/json"
|
||||
"errors"
|
||||
"io"
|
||||
"net/http"
|
||||
"strconv"
|
||||
"strings"
|
||||
"time"
|
||||
|
||||
log "github.com/sirupsen/logrus"
|
||||
)
|
||||
|
||||
// StartAutoRefresh launches a background loop that evaluates auth freshness
|
||||
// every few seconds and triggers refresh operations when required.
|
||||
// Only one loop is kept alive; starting a new one cancels the previous run.
|
||||
func (m *Manager) StartAutoRefresh(parent context.Context, interval time.Duration) {
|
||||
if interval <= 0 || interval > refreshCheckInterval {
|
||||
interval = refreshCheckInterval
|
||||
} else {
|
||||
interval = refreshCheckInterval
|
||||
}
|
||||
if m.refreshCancel != nil {
|
||||
m.refreshCancel()
|
||||
m.refreshCancel = nil
|
||||
}
|
||||
ctx, cancel := context.WithCancel(parent)
|
||||
m.refreshCancel = cancel
|
||||
go func() {
|
||||
ticker := time.NewTicker(interval)
|
||||
defer ticker.Stop()
|
||||
m.checkRefreshes(ctx)
|
||||
for {
|
||||
select {
|
||||
case <-ctx.Done():
|
||||
return
|
||||
case <-ticker.C:
|
||||
m.checkRefreshes(ctx)
|
||||
}
|
||||
}
|
||||
}()
|
||||
}
|
||||
|
||||
// StopAutoRefresh cancels the background refresh loop, if running.
|
||||
func (m *Manager) StopAutoRefresh() {
|
||||
if m.refreshCancel != nil {
|
||||
m.refreshCancel()
|
||||
m.refreshCancel = nil
|
||||
}
|
||||
}
|
||||
|
||||
func (m *Manager) checkRefreshes(ctx context.Context) {
|
||||
// log.Debugf("checking refreshes")
|
||||
now := time.Now()
|
||||
snapshot := m.snapshotAuths()
|
||||
for _, a := range snapshot {
|
||||
typ, _ := a.AccountInfo()
|
||||
if typ != "api_key" {
|
||||
if !m.shouldRefresh(a, now) {
|
||||
continue
|
||||
}
|
||||
log.Debugf("checking refresh for %s, %s, %s", a.Provider, a.ID, typ)
|
||||
|
||||
if exec := m.executorFor(a.Provider); exec == nil {
|
||||
continue
|
||||
}
|
||||
if !m.markRefreshPending(a.ID, now) {
|
||||
continue
|
||||
}
|
||||
go m.refreshAuth(ctx, a.ID)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func (m *Manager) snapshotAuths() []*Auth {
|
||||
m.mu.RLock()
|
||||
defer m.mu.RUnlock()
|
||||
out := make([]*Auth, 0, len(m.auths))
|
||||
for _, a := range m.auths {
|
||||
out = append(out, a.Clone())
|
||||
}
|
||||
return out
|
||||
}
|
||||
|
||||
func (m *Manager) shouldRefresh(a *Auth, now time.Time) bool {
|
||||
if a == nil || a.Disabled {
|
||||
return false
|
||||
}
|
||||
if !a.NextRefreshAfter.IsZero() && now.Before(a.NextRefreshAfter) {
|
||||
return false
|
||||
}
|
||||
if evaluator, ok := a.Runtime.(RefreshEvaluator); ok && evaluator != nil {
|
||||
return evaluator.ShouldRefresh(now, a)
|
||||
}
|
||||
|
||||
lastRefresh := a.LastRefreshedAt
|
||||
if lastRefresh.IsZero() {
|
||||
if ts, ok := authLastRefreshTimestamp(a); ok {
|
||||
lastRefresh = ts
|
||||
}
|
||||
}
|
||||
|
||||
expiry, hasExpiry := a.ExpirationTime()
|
||||
|
||||
if interval := authPreferredInterval(a); interval > 0 {
|
||||
if hasExpiry && !expiry.IsZero() {
|
||||
if !expiry.After(now) {
|
||||
return true
|
||||
}
|
||||
if expiry.Sub(now) <= interval {
|
||||
return true
|
||||
}
|
||||
}
|
||||
if lastRefresh.IsZero() {
|
||||
return true
|
||||
}
|
||||
return now.Sub(lastRefresh) >= interval
|
||||
}
|
||||
|
||||
provider := strings.ToLower(a.Provider)
|
||||
lead := ProviderRefreshLead(provider, a.Runtime)
|
||||
if lead == nil {
|
||||
return false
|
||||
}
|
||||
if *lead <= 0 {
|
||||
if hasExpiry && !expiry.IsZero() {
|
||||
return now.After(expiry)
|
||||
}
|
||||
return false
|
||||
}
|
||||
if hasExpiry && !expiry.IsZero() {
|
||||
return time.Until(expiry) <= *lead
|
||||
}
|
||||
if !lastRefresh.IsZero() {
|
||||
return now.Sub(lastRefresh) >= *lead
|
||||
}
|
||||
return true
|
||||
}
|
||||
|
||||
func authPreferredInterval(a *Auth) time.Duration {
|
||||
if a == nil {
|
||||
return 0
|
||||
}
|
||||
if d := durationFromMetadata(a.Metadata, "refresh_interval_seconds", "refreshIntervalSeconds", "refresh_interval", "refreshInterval"); d > 0 {
|
||||
return d
|
||||
}
|
||||
if d := durationFromAttributes(a.Attributes, "refresh_interval_seconds", "refreshIntervalSeconds", "refresh_interval", "refreshInterval"); d > 0 {
|
||||
return d
|
||||
}
|
||||
return 0
|
||||
}
|
||||
|
||||
func durationFromMetadata(meta map[string]any, keys ...string) time.Duration {
|
||||
if len(meta) == 0 {
|
||||
return 0
|
||||
}
|
||||
for _, key := range keys {
|
||||
if val, ok := meta[key]; ok {
|
||||
if dur := parseDurationValue(val); dur > 0 {
|
||||
return dur
|
||||
}
|
||||
}
|
||||
}
|
||||
return 0
|
||||
}
|
||||
|
||||
func durationFromAttributes(attrs map[string]string, keys ...string) time.Duration {
|
||||
if len(attrs) == 0 {
|
||||
return 0
|
||||
}
|
||||
for _, key := range keys {
|
||||
if val, ok := attrs[key]; ok {
|
||||
if dur := parseDurationString(val); dur > 0 {
|
||||
return dur
|
||||
}
|
||||
}
|
||||
}
|
||||
return 0
|
||||
}
|
||||
|
||||
func parseDurationValue(val any) time.Duration {
|
||||
switch v := val.(type) {
|
||||
case time.Duration:
|
||||
if v <= 0 {
|
||||
return 0
|
||||
}
|
||||
return v
|
||||
case int:
|
||||
if v <= 0 {
|
||||
return 0
|
||||
}
|
||||
return time.Duration(v) * time.Second
|
||||
case int32:
|
||||
if v <= 0 {
|
||||
return 0
|
||||
}
|
||||
return time.Duration(v) * time.Second
|
||||
case int64:
|
||||
if v <= 0 {
|
||||
return 0
|
||||
}
|
||||
return time.Duration(v) * time.Second
|
||||
case uint:
|
||||
if v == 0 {
|
||||
return 0
|
||||
}
|
||||
return time.Duration(v) * time.Second
|
||||
case uint32:
|
||||
if v == 0 {
|
||||
return 0
|
||||
}
|
||||
return time.Duration(v) * time.Second
|
||||
case uint64:
|
||||
if v == 0 {
|
||||
return 0
|
||||
}
|
||||
return time.Duration(v) * time.Second
|
||||
case float32:
|
||||
if v <= 0 {
|
||||
return 0
|
||||
}
|
||||
return time.Duration(float64(v) * float64(time.Second))
|
||||
case float64:
|
||||
if v <= 0 {
|
||||
return 0
|
||||
}
|
||||
return time.Duration(v * float64(time.Second))
|
||||
case json.Number:
|
||||
if i, err := v.Int64(); err == nil {
|
||||
if i <= 0 {
|
||||
return 0
|
||||
}
|
||||
return time.Duration(i) * time.Second
|
||||
}
|
||||
if f, err := v.Float64(); err == nil && f > 0 {
|
||||
return time.Duration(f * float64(time.Second))
|
||||
}
|
||||
case string:
|
||||
return parseDurationString(v)
|
||||
}
|
||||
return 0
|
||||
}
|
||||
|
||||
func parseDurationString(raw string) time.Duration {
|
||||
s := strings.TrimSpace(raw)
|
||||
if s == "" {
|
||||
return 0
|
||||
}
|
||||
if dur, err := time.ParseDuration(s); err == nil && dur > 0 {
|
||||
return dur
|
||||
}
|
||||
if secs, err := strconv.ParseFloat(s, 64); err == nil && secs > 0 {
|
||||
return time.Duration(secs * float64(time.Second))
|
||||
}
|
||||
return 0
|
||||
}
|
||||
|
||||
func authLastRefreshTimestamp(a *Auth) (time.Time, bool) {
|
||||
if a == nil {
|
||||
return time.Time{}, false
|
||||
}
|
||||
if a.Metadata != nil {
|
||||
if ts, ok := lookupMetadataTime(a.Metadata, "last_refresh", "lastRefresh", "last_refreshed_at", "lastRefreshedAt"); ok {
|
||||
return ts, true
|
||||
}
|
||||
}
|
||||
if a.Attributes != nil {
|
||||
for _, key := range []string{"last_refresh", "lastRefresh", "last_refreshed_at", "lastRefreshedAt"} {
|
||||
if val := strings.TrimSpace(a.Attributes[key]); val != "" {
|
||||
if ts, ok := parseTimeValue(val); ok {
|
||||
return ts, true
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return time.Time{}, false
|
||||
}
|
||||
|
||||
func lookupMetadataTime(meta map[string]any, keys ...string) (time.Time, bool) {
|
||||
for _, key := range keys {
|
||||
if val, ok := meta[key]; ok {
|
||||
if ts, ok1 := parseTimeValue(val); ok1 {
|
||||
return ts, true
|
||||
}
|
||||
}
|
||||
}
|
||||
return time.Time{}, false
|
||||
}
|
||||
|
||||
func (m *Manager) markRefreshPending(id string, now time.Time) bool {
|
||||
m.mu.Lock()
|
||||
defer m.mu.Unlock()
|
||||
auth, ok := m.auths[id]
|
||||
if !ok || auth == nil || auth.Disabled {
|
||||
return false
|
||||
}
|
||||
if !auth.NextRefreshAfter.IsZero() && now.Before(auth.NextRefreshAfter) {
|
||||
return false
|
||||
}
|
||||
auth.NextRefreshAfter = now.Add(refreshPendingBackoff)
|
||||
m.auths[id] = auth
|
||||
return true
|
||||
}
|
||||
|
||||
func (m *Manager) refreshAuth(ctx context.Context, id string) {
|
||||
if ctx == nil {
|
||||
ctx = context.Background()
|
||||
}
|
||||
m.mu.RLock()
|
||||
auth := m.auths[id]
|
||||
var exec ProviderExecutor
|
||||
if auth != nil {
|
||||
exec = m.executors[auth.Provider]
|
||||
}
|
||||
m.mu.RUnlock()
|
||||
if auth == nil || exec == nil {
|
||||
return
|
||||
}
|
||||
cloned := auth.Clone()
|
||||
updated, err := exec.Refresh(ctx, cloned)
|
||||
if err != nil && errors.Is(err, context.Canceled) {
|
||||
log.Debugf("refresh canceled for %s, %s", auth.Provider, auth.ID)
|
||||
return
|
||||
}
|
||||
log.Debugf("refreshed %s, %s, %v", auth.Provider, auth.ID, err)
|
||||
now := time.Now()
|
||||
if err != nil {
|
||||
m.mu.Lock()
|
||||
if current := m.auths[id]; current != nil {
|
||||
current.NextRefreshAfter = now.Add(refreshFailureBackoff)
|
||||
current.LastError = &Error{Message: err.Error()}
|
||||
m.auths[id] = current
|
||||
}
|
||||
m.mu.Unlock()
|
||||
return
|
||||
}
|
||||
if updated == nil {
|
||||
updated = cloned
|
||||
}
|
||||
// Preserve runtime created by the executor during Refresh.
|
||||
// If executor didn't set one, fall back to the previous runtime.
|
||||
if updated.Runtime == nil {
|
||||
updated.Runtime = auth.Runtime
|
||||
}
|
||||
updated.LastRefreshedAt = now
|
||||
updated.NextRefreshAfter = time.Time{}
|
||||
updated.LastError = nil
|
||||
updated.UpdatedAt = now
|
||||
_, _ = m.Update(ctx, updated)
|
||||
}
|
||||
|
||||
func (m *Manager) executorFor(provider string) ProviderExecutor {
|
||||
m.mu.RLock()
|
||||
defer m.mu.RUnlock()
|
||||
return m.executors[provider]
|
||||
}
|
||||
|
||||
// roundTripperContextKey is an unexported context key type to avoid collisions.
|
||||
type roundTripperContextKey struct{}
|
||||
|
||||
// roundTripperFor retrieves an HTTP RoundTripper for the given auth if a provider is registered.
|
||||
func (m *Manager) roundTripperFor(auth *Auth) http.RoundTripper {
|
||||
m.mu.RLock()
|
||||
p := m.rtProvider
|
||||
m.mu.RUnlock()
|
||||
if p == nil || auth == nil {
|
||||
return nil
|
||||
}
|
||||
return p.RoundTripperFor(auth)
|
||||
}
|
||||
|
||||
// RoundTripperProvider defines a minimal provider of per-auth HTTP transports.
|
||||
type RoundTripperProvider interface {
|
||||
RoundTripperFor(auth *Auth) http.RoundTripper
|
||||
}
|
||||
|
||||
// RequestPreparer is an optional interface that provider executors can implement
|
||||
// to mutate outbound HTTP requests with provider credentials.
|
||||
type RequestPreparer interface {
|
||||
PrepareRequest(req *http.Request, auth *Auth) error
|
||||
}
|
||||
|
||||
func executorKeyFromAuth(auth *Auth) string {
|
||||
if auth == nil {
|
||||
return ""
|
||||
}
|
||||
if auth.Attributes != nil {
|
||||
providerKey := strings.TrimSpace(auth.Attributes["provider_key"])
|
||||
compatName := strings.TrimSpace(auth.Attributes["compat_name"])
|
||||
if compatName != "" {
|
||||
if providerKey == "" {
|
||||
providerKey = compatName
|
||||
}
|
||||
return strings.ToLower(providerKey)
|
||||
}
|
||||
}
|
||||
return strings.ToLower(strings.TrimSpace(auth.Provider))
|
||||
}
|
||||
|
||||
// InjectCredentials delegates per-provider HTTP request preparation when supported.
|
||||
// If the registered executor for the auth provider implements RequestPreparer,
|
||||
// it will be invoked to modify the request (e.g., add headers).
|
||||
func (m *Manager) InjectCredentials(req *http.Request, authID string) error {
|
||||
if req == nil || authID == "" {
|
||||
return nil
|
||||
}
|
||||
m.mu.RLock()
|
||||
a := m.auths[authID]
|
||||
var exec ProviderExecutor
|
||||
if a != nil {
|
||||
exec = m.executors[executorKeyFromAuth(a)]
|
||||
}
|
||||
m.mu.RUnlock()
|
||||
if a == nil || exec == nil {
|
||||
return nil
|
||||
}
|
||||
if p, ok := exec.(RequestPreparer); ok && p != nil {
|
||||
return p.PrepareRequest(req, a)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// PrepareHttpRequest injects provider credentials into the supplied HTTP request.
|
||||
func (m *Manager) PrepareHttpRequest(ctx context.Context, auth *Auth, req *http.Request) error {
|
||||
if m == nil {
|
||||
return &Error{Code: "provider_not_found", Message: "manager is nil"}
|
||||
}
|
||||
if auth == nil {
|
||||
return &Error{Code: "auth_not_found", Message: "auth is nil"}
|
||||
}
|
||||
if req == nil {
|
||||
return &Error{Code: "invalid_request", Message: "http request is nil"}
|
||||
}
|
||||
if ctx != nil {
|
||||
*req = *req.WithContext(ctx)
|
||||
}
|
||||
providerKey := executorKeyFromAuth(auth)
|
||||
if providerKey == "" {
|
||||
return &Error{Code: "provider_not_found", Message: "auth provider is empty"}
|
||||
}
|
||||
exec := m.executorFor(providerKey)
|
||||
if exec == nil {
|
||||
return &Error{Code: "provider_not_found", Message: "executor not registered for provider: " + providerKey}
|
||||
}
|
||||
preparer, ok := exec.(RequestPreparer)
|
||||
if !ok || preparer == nil {
|
||||
return &Error{Code: "not_supported", Message: "executor does not support http request preparation"}
|
||||
}
|
||||
return preparer.PrepareRequest(req, auth)
|
||||
}
|
||||
|
||||
// NewHttpRequest constructs a new HTTP request and injects provider credentials into it.
|
||||
func (m *Manager) NewHttpRequest(ctx context.Context, auth *Auth, method, targetURL string, body []byte, headers http.Header) (*http.Request, error) {
|
||||
if ctx == nil {
|
||||
ctx = context.Background()
|
||||
}
|
||||
method = strings.TrimSpace(method)
|
||||
if method == "" {
|
||||
method = http.MethodGet
|
||||
}
|
||||
var reader io.Reader
|
||||
if body != nil {
|
||||
reader = bytes.NewReader(body)
|
||||
}
|
||||
httpReq, err := http.NewRequestWithContext(ctx, method, targetURL, reader)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if headers != nil {
|
||||
httpReq.Header = headers.Clone()
|
||||
}
|
||||
if errPrepare := m.PrepareHttpRequest(ctx, auth, httpReq); errPrepare != nil {
|
||||
return nil, errPrepare
|
||||
}
|
||||
return httpReq, nil
|
||||
}
|
||||
|
||||
// HttpRequest injects provider credentials into the supplied HTTP request and executes it.
|
||||
func (m *Manager) HttpRequest(ctx context.Context, auth *Auth, req *http.Request) (*http.Response, error) {
|
||||
if m == nil {
|
||||
return nil, &Error{Code: "provider_not_found", Message: "manager is nil"}
|
||||
}
|
||||
if auth == nil {
|
||||
return nil, &Error{Code: "auth_not_found", Message: "auth is nil"}
|
||||
}
|
||||
if req == nil {
|
||||
return nil, &Error{Code: "invalid_request", Message: "http request is nil"}
|
||||
}
|
||||
providerKey := executorKeyFromAuth(auth)
|
||||
if providerKey == "" {
|
||||
return nil, &Error{Code: "provider_not_found", Message: "auth provider is empty"}
|
||||
}
|
||||
exec := m.executorFor(providerKey)
|
||||
if exec == nil {
|
||||
return nil, &Error{Code: "provider_not_found", Message: "executor not registered for provider: " + providerKey}
|
||||
}
|
||||
return exec.HttpRequest(ctx, auth, req)
|
||||
}
|
||||
Reference in New Issue
Block a user