coder · johnstcn · May 2, 2025 · Apr 9, 2025 · Apr 9, 2025 · Apr 10, 2025
diff --git a/cli/server.go b/cli/server.go
@@ -61,6 +61,7 @@ import (
 	"github.com/coder/serpent"
 	"github.com/coder/wgtunnel/tunnelsdk"
 
+	"github.com/coder/coder/v2/coderd/ai"
 	"github.com/coder/coder/v2/coderd/entitlements"
 	"github.com/coder/coder/v2/coderd/notifications/reports"
 	"github.com/coder/coder/v2/coderd/runtimeconfig"
@@ -610,6 +611,22 @@ func (r *RootCmd) Server(newAPI func(context.Context, *coderd.Options) (*coderd.
 				)
 			}
 
+			aiProviders, err := ReadAIProvidersFromEnv(os.Environ())
+			if err != nil {
+				return xerrors.Errorf("read ai providers from env: %w", err)
+			}
+			vals.AI.Value.Providers = append(vals.AI.Value.Providers, aiProviders...)
+			for _, provider := range aiProviders {
+				logger.Debug(
+					ctx, "loaded ai provider",
+					slog.F("type", provider.Type),
+				)
+			}
+			languageModels, err := ai.ModelsFromConfig(ctx, vals.AI.Value.Providers)
+			if err != nil {
+				return xerrors.Errorf("create language models: %w", err)
+			}
+
 			realIPConfig, err := httpmw.ParseRealIPConfig(vals.ProxyTrustedHeaders, vals.ProxyTrustedOrigins)
 			if err != nil {
 				return xerrors.Errorf("parse real ip config: %w", err)
@@ -640,6 +657,7 @@ func (r *RootCmd) Server(newAPI func(context.Context, *coderd.Options) (*coderd.
 				CacheDir:                    cacheDir,
 				GoogleTokenValidator:        googleTokenValidator,
 				ExternalAuthConfigs:         externalAuthConfigs,
+				LanguageModels:              languageModels,
 				RealIPConfig:                realIPConfig,
 				SSHKeygenAlgorithm:          sshKeygenAlgorithm,
 				TracerProvider:              tracerProvider,
@@ -2621,6 +2639,77 @@ func redirectHTTPToHTTPSDeprecation(ctx context.Context, logger slog.Logger, inv
 	}
 }
 
+func ReadAIProvidersFromEnv(environ []string) ([]codersdk.AIProviderConfig, error) {
+	// The index numbers must be in-order.
+	sort.Strings(environ)
+
+	var providers []codersdk.AIProviderConfig
+	for _, v := range serpent.ParseEnviron(environ, "CODER_AI_PROVIDER_") {
+		tokens := strings.SplitN(v.Name, "_", 2)
+		if len(tokens) != 2 {
+			return nil, xerrors.Errorf("invalid env var: %s", v.Name)
+		}
+
+		providerNum, err := strconv.Atoi(tokens[0])
+		if err != nil {
+			return nil, xerrors.Errorf("parse number: %s", v.Name)
+		}
+
+		var provider codersdk.AIProviderConfig
+		switch {
+		case len(providers) < providerNum:
+			return nil, xerrors.Errorf(
+				"provider num %v skipped: %s",
+				len(providers),
+				v.Name,
+			)
+		case len(providers) == providerNum:
+			// At the next next provider.
+			providers = append(providers, provider)
+		case len(providers) == providerNum+1:
+			// At the current provider.
+			provider = providers[providerNum]
+		}
+
+		key := tokens[1]
+		switch key {
+		case "TYPE":
+			provider.Type = v.Value
+		case "API_KEY":
+			provider.APIKey = v.Value
+		case "BASE_URL":
+			provider.BaseURL = v.Value
+		case "MODELS":
+			provider.Models = strings.Split(v.Value, ",")
+		}
+		providers[providerNum] = provider
+	}
+	for _, envVar := range environ {
+		tokens := strings.SplitN(envVar, "=", 2)
+		if len(tokens) != 2 {
+			continue
+		}
+		switch tokens[0] {
+		case "OPENAI_API_KEY":
+			providers = append(providers, codersdk.AIProviderConfig{
+				Type:   "openai",
+				APIKey: tokens[1],
+			})
+		case "ANTHROPIC_API_KEY":
+			providers = append(providers, codersdk.AIProviderConfig{
+				Type:   "anthropic",
+				APIKey: tokens[1],
+			})
+		case "GOOGLE_API_KEY":
+			providers = append(providers, codersdk.AIProviderConfig{
+				Type:   "google",
+				APIKey: tokens[1],
+			})
+		}
+	}
+	return providers, nil
+}
+
 // ReadExternalAuthProvidersFromEnv is provided for compatibility purposes with
 // the viper CLI.
 func ReadExternalAuthProvidersFromEnv(environ []string) ([]codersdk.ExternalAuthConfig, error) {

diff --git a/cli/testdata/server-config.yaml.golden b/cli/testdata/server-config.yaml.golden
@@ -519,6 +519,9 @@ client:
 # Support links to display in the top right drop down menu.
 # (default: <unset>, type: struct[[]codersdk.LinkConfig])
 supportLinks: []
+# Configure AI providers.
+# (default: <unset>, type: struct[codersdk.AIConfig])
+ai: {}
 # External Authentication providers.
 # (default: <unset>, type: struct[[]codersdk.ExternalAuthConfig])
 externalAuthProviders: []

diff --git a/coderd/ai/ai.go b/coderd/ai/ai.go
@@ -0,0 +1,167 @@
+package ai
+
+import (
+	"context"
+
+	"github.com/anthropics/anthropic-sdk-go"
+	anthropicoption "github.com/anthropics/anthropic-sdk-go/option"
+	"github.com/kylecarbs/aisdk-go"
+	"github.com/openai/openai-go"
+	openaioption "github.com/openai/openai-go/option"
+	"golang.org/x/xerrors"
+	"google.golang.org/genai"
+
+	"github.com/coder/coder/v2/codersdk"
+)
+
+type LanguageModel struct {
+	codersdk.LanguageModel
+	StreamFunc StreamFunc
+}
+
+type StreamOptions struct {
+	SystemPrompt string
+	Model        string
+	Messages     []aisdk.Message
+	Thinking     bool
+	Tools        []aisdk.Tool
+}
+
+type StreamFunc func(ctx context.Context, options StreamOptions) (aisdk.DataStream, error)
+
+// LanguageModels is a map of language model ID to language model.
+type LanguageModels map[string]LanguageModel
+
+func ModelsFromConfig(ctx context.Context, configs []codersdk.AIProviderConfig) (LanguageModels, error) {
+	models := make(LanguageModels)
+
+	for _, config := range configs {
+		var streamFunc StreamFunc
+
+		switch config.Type {
+		case "openai":
+			opts := []openaioption.RequestOption{
+				openaioption.WithAPIKey(config.APIKey),
+			}
+			if config.BaseURL != "" {
+				opts = append(opts, openaioption.WithBaseURL(config.BaseURL))
+			}
+			client := openai.NewClient(opts...)
+			streamFunc = func(ctx context.Context, options StreamOptions) (aisdk.DataStream, error) {
+				openaiMessages, err := aisdk.MessagesToOpenAI(options.Messages)
+				if err != nil {
+					return nil, err
+				}
+				tools := aisdk.ToolsToOpenAI(options.Tools)
+				if options.SystemPrompt != "" {
+					openaiMessages = append([]openai.ChatCompletionMessageParamUnion{
+						openai.SystemMessage(options.SystemPrompt),
+					}, openaiMessages...)
+				}
+
+				return aisdk.OpenAIToDataStream(client.Chat.Completions.NewStreaming(ctx, openai.ChatCompletionNewParams{
+					Messages:  openaiMessages,
+					Model:     options.Model,
+					Tools:     tools,
+					MaxTokens: openai.Int(8192),
+				})), nil
+			}
+			if config.Models == nil {
+				models, err := client.Models.List(ctx)
+				if err != nil {
+					return nil, err
+				}
+				config.Models = make([]string, len(models.Data))
+				for i, model := range models.Data {
+					config.Models[i] = model.ID
+				}
+			}
+		case "anthropic":
+			client := anthropic.NewClient(anthropicoption.WithAPIKey(config.APIKey))
+			streamFunc = func(ctx context.Context, options StreamOptions) (aisdk.DataStream, error) {
+				anthropicMessages, systemMessage, err := aisdk.MessagesToAnthropic(options.Messages)
+				if err != nil {
+					return nil, err
+				}
+				if options.SystemPrompt != "" {
+					systemMessage = []anthropic.TextBlockParam{
+						*anthropic.NewTextBlock(options.SystemPrompt).OfRequestTextBlock,
+					}
+				}
+				return aisdk.AnthropicToDataStream(client.Messages.NewStreaming(ctx, anthropic.MessageNewParams{
+					Messages:  anthropicMessages,
+					Model:     options.Model,
+					System:    systemMessage,
+					Tools:     aisdk.ToolsToAnthropic(options.Tools),
+					MaxTokens: 8192,
+				})), nil
+			}
+			if config.Models == nil {
+				models, err := client.Models.List(ctx, anthropic.ModelListParams{})
+				if err != nil {
+					return nil, err
+				}
+				config.Models = make([]string, len(models.Data))
+				for i, model := range models.Data {
+					config.Models[i] = model.ID
+				}
+			}
+		case "google":
+			client, err := genai.NewClient(ctx, &genai.ClientConfig{
+				APIKey:  config.APIKey,
+				Backend: genai.BackendGeminiAPI,
+			})
+			if err != nil {
+				return nil, err
+			}
+			streamFunc = func(ctx context.Context, options StreamOptions) (aisdk.DataStream, error) {
+				googleMessages, err := aisdk.MessagesToGoogle(options.Messages)
+				if err != nil {
+					return nil, err
+				}
+				tools, err := aisdk.ToolsToGoogle(options.Tools)
+				if err != nil {
+					return nil, err
+				}
+				var systemInstruction *genai.Content
+				if options.SystemPrompt != "" {
+					systemInstruction = &genai.Content{
+						Parts: []*genai.Part{
+							genai.NewPartFromText(options.SystemPrompt),
+						},
+						Role: "model",
+					}
+				}
+				return aisdk.GoogleToDataStream(client.Models.GenerateContentStream(ctx, options.Model, googleMessages, &genai.GenerateContentConfig{
+					SystemInstruction: systemInstruction,
+					Tools:             tools,
+				})), nil
+			}
+			if config.Models == nil {
+				models, err := client.Models.List(ctx, &genai.ListModelsConfig{})
+				if err != nil {
+					return nil, err
+				}
+				config.Models = make([]string, len(models.Items))
+				for i, model := range models.Items {
+					config.Models[i] = model.Name
+				}
+			}
+		default:
+			return nil, xerrors.Errorf("unsupported model type: %s", config.Type)
+		}
+
+		for _, model := range config.Models {
+			models[model] = LanguageModel{
+				LanguageModel: codersdk.LanguageModel{
+					ID:          model,
+					DisplayName: model,
+					Provider:    config.Type,
+				},
+				StreamFunc: streamFunc,
+			}
+		}
+	}
+
+	return models, nil
+}