From ef60b1cd7e120fb3bfd72370c8ea4b61887c5d2c Mon Sep 17 00:00:00 2001 From: RCD <90105158+Finesssee@users.noreply.github.com> Date: Sun, 1 Feb 2026 12:02:14 +0700 Subject: [PATCH] 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) --- sdk/cliproxy/auth/conductor.go | 864 --------------------------- sdk/cliproxy/auth/conductor_oauth.go | 383 ++++++++++++ sdk/cliproxy/auth/conductor_token.go | 501 ++++++++++++++++ 3 files changed, 884 insertions(+), 864 deletions(-) create mode 100644 sdk/cliproxy/auth/conductor_oauth.go create mode 100644 sdk/cliproxy/auth/conductor_token.go diff --git a/sdk/cliproxy/auth/conductor.go b/sdk/cliproxy/auth/conductor.go index b82e0e10..39e2411e 100644 --- a/sdk/cliproxy/auth/conductor.go +++ b/sdk/cliproxy/auth/conductor.go @@ -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) -} diff --git a/sdk/cliproxy/auth/conductor_oauth.go b/sdk/cliproxy/auth/conductor_oauth.go new file mode 100644 index 00000000..54d9932e --- /dev/null +++ b/sdk/cliproxy/auth/conductor_oauth.go @@ -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 +} diff --git a/sdk/cliproxy/auth/conductor_token.go b/sdk/cliproxy/auth/conductor_token.go new file mode 100644 index 00000000..b2ede6ee --- /dev/null +++ b/sdk/cliproxy/auth/conductor_token.go @@ -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) +}