Update config structure

internal/providers/openai/openai.go

@@ -55,7 +55,6 @@ func NewAzure(azureCfg config.AzureOpenAIConfig) *Provider {
 	return &Provider{
 		cfg: config.ProviderConfig{
 			APIKey: azureCfg.APIKey,
-			Model:  azureCfg.DeploymentID,
 		},
 		client: client,
 		azure:  true,

internal/providers/providers.go

@@ -3,7 +3,6 @@ package providers
 import (
 	"context"
 	"fmt"
-	"strings"
 
 	"github.com/yourusername/go-llm-gateway/internal/api"
 	"github.com/yourusername/go-llm-gateway/internal/config"
@@ -19,27 +18,38 @@ type Provider interface {
 	GenerateStream(ctx context.Context, req *api.ResponseRequest) (<-chan *api.StreamChunk, <-chan error)
 }
 
-// Registry keeps track of registered providers by key (e.g. "openai").
+// Registry keeps track of registered providers and model-to-provider mappings.
 type Registry struct {
-	providers map[string]Provider
+	providers        map[string]Provider
+	models           map[string]string // model name -> provider entry name
+	providerModelIDs map[string]string // model name -> provider model ID
+	modelList        []config.ModelEntry
 }
 
 // NewRegistry constructs provider implementations from configuration.
-func NewRegistry(cfg config.ProvidersConfig) (*Registry, error) {
-	reg := &Registry{providers: make(map[string]Provider)}
+func NewRegistry(entries map[string]config.ProviderEntry, models []config.ModelEntry) (*Registry, error) {
+	reg := &Registry{
+		providers:        make(map[string]Provider),
+		models:           make(map[string]string),
+		providerModelIDs: make(map[string]string),
+		modelList:        models,
+	}
 
-	if cfg.Google.APIKey != "" {
-		reg.providers[googleprovider.Name] = googleprovider.New(cfg.Google)
+	for name, entry := range entries {
+		p, err := buildProvider(entry)
+		if err != nil {
+			return nil, fmt.Errorf("provider %q: %w", name, err)
+		}
+		if p != nil {
+			reg.providers[name] = p
+		}
 	}
-	if cfg.AzureAnthropic.APIKey != "" && cfg.AzureAnthropic.Endpoint != "" {
-		reg.providers[anthropicprovider.Name] = anthropicprovider.NewAzure(cfg.AzureAnthropic)
-	} else if cfg.Anthropic.APIKey != "" {
-		reg.providers[anthropicprovider.Name] = anthropicprovider.New(cfg.Anthropic)
-	}
-	if cfg.AzureOpenAI.APIKey != "" && cfg.AzureOpenAI.Endpoint != "" {
-		reg.providers[openaiprovider.Name] = openaiprovider.NewAzure(cfg.AzureOpenAI)
-	} else if cfg.OpenAI.APIKey != "" {
-		reg.providers[openaiprovider.Name] = openaiprovider.New(cfg.OpenAI)
+
+	for _, m := range models {
+		reg.models[m.Name] = m.Provider
+		if m.ProviderModelID != "" {
+			reg.providerModelIDs[m.Name] = m.ProviderModelID
+		}
 	}
 
 	if len(reg.providers) == 0 {
@@ -49,26 +59,77 @@ func NewRegistry(cfg config.ProvidersConfig) (*Registry, error) {
 	return reg, nil
 }
 
-// Get returns provider by key.
+func buildProvider(entry config.ProviderEntry) (Provider, error) {
+	if entry.APIKey == "" {
+		return nil, nil
+	}
+
+	switch entry.Type {
+	case "openai":
+		return openaiprovider.New(config.ProviderConfig{
+			APIKey:   entry.APIKey,
+			Endpoint: entry.Endpoint,
+		}), nil
+	case "azureopenai":
+		if entry.Endpoint == "" {
+			return nil, fmt.Errorf("endpoint is required for azureopenai")
+		}
+		return openaiprovider.NewAzure(config.AzureOpenAIConfig{
+			APIKey:     entry.APIKey,
+			Endpoint:   entry.Endpoint,
+			APIVersion: entry.APIVersion,
+		}), nil
+	case "anthropic":
+		return anthropicprovider.New(config.ProviderConfig{
+			APIKey:   entry.APIKey,
+			Endpoint: entry.Endpoint,
+		}), nil
+	case "azureanthropic":
+		if entry.Endpoint == "" {
+			return nil, fmt.Errorf("endpoint is required for azureanthropic")
+		}
+		return anthropicprovider.NewAzure(config.AzureAnthropicConfig{
+			APIKey:   entry.APIKey,
+			Endpoint: entry.Endpoint,
+		}), nil
+	case "google":
+		return googleprovider.New(config.ProviderConfig{
+			APIKey:   entry.APIKey,
+			Endpoint: entry.Endpoint,
+		}), nil
+	default:
+		return nil, fmt.Errorf("unknown provider type %q", entry.Type)
+	}
+}
+
+// Get returns provider by entry name.
 func (r *Registry) Get(name string) (Provider, bool) {
 	p, ok := r.providers[name]
 	return p, ok
 }
 
-// Default returns provider based on inferred name.
+// Models returns the list of configured models and their provider entry names.
+func (r *Registry) Models() []struct{ Provider, Model string } {
+	var out []struct{ Provider, Model string }
+	for _, m := range r.modelList {
+		out = append(out, struct{ Provider, Model string }{Provider: m.Provider, Model: m.Name})
+	}
+	return out
+}
+
+// ResolveModelID returns the provider_model_id for a model, falling back to the model name itself.
+func (r *Registry) ResolveModelID(model string) string {
+	if id, ok := r.providerModelIDs[model]; ok {
+		return id
+	}
+	return model
+}
+
+// Default returns the provider for the given model name.
 func (r *Registry) Default(model string) (Provider, error) {
 	if model != "" {
-		switch {
-		case strings.HasPrefix(model, "gpt") || strings.HasPrefix(model, "o1") || strings.HasPrefix(model, "o3"):
-			if p, ok := r.providers[openaiprovider.Name]; ok {
-				return p, nil
-			}
-		case strings.HasPrefix(model, "claude"):
-			if p, ok := r.providers[anthropicprovider.Name]; ok {
-				return p, nil
-			}
-		case strings.HasPrefix(model, "gemini"):
-			if p, ok := r.providers[googleprovider.Name]; ok {
+		if providerName, ok := r.models[model]; ok {
+			if p, ok := r.providers[providerName]; ok {
 				return p, nil
 			}
 		}