package main

import (

"encoding/json"

"fmt"

"os"

"reflect"

"strings"

"github.com/shopspring/decimal"

"golang.org/x/xerrors"

"github.com/coder/coder/v2/codersdk"

)

// SchemaField describes a single form field in the generated schema.

type SchemaField struct {

JSONName string `json:"json_name"`

GoName string `json:"go_name"`

Type string `json:"type"`

Description string `json:"description,omitempty"`

Label string `json:"label,omitempty"`

Required bool `json:"required"`

Enum []string `json:"enum,omitempty"`

InputType string `json:"input_type"`

Hidden bool `json:"hidden,omitempty"`

VisibleWhen string `json:"visible_when,omitempty"`

ConflictsWith []string `json:"conflicts_with,omitempty"`

VisibleForProviders []string `json:"visible_for_providers,omitempty"`

}

// FieldGroup holds the fields for a struct or provider.

type FieldGroup struct {

Fields []SchemaField `json:"fields"`

}

// Schema is the top-level output structure.

type Schema struct {

General FieldGroup `json:"general"`

Providers map[string]FieldGroup `json:"providers"`

ProviderAliases map[string]string `json:"provider_aliases"`

}

func main() {

schema := Schema{

Providers: make(map[string]FieldGroup),

ProviderAliases: map[string]string{

"azure": "openai",

"bedrock": "anthropic",

},

}

// General options from ChatModelCallConfig, excluding

// the provider_options field which is handled separately.

schema.General = extractFields(

reflect.TypeOf(codersdk.ChatModelCallConfig{}),

"",

map[string]bool{"ProviderOptions": true},

nil,

)

if err := validateFieldReferences("general", schema.General); err != nil {

_, _ = fmt.Fprintln(os.Stderr, err)

os.Exit(1)

}

// Provider-specific options. Each entry maps a provider key

// to the concrete options struct used for that provider.

providerTypes := []struct {

key string

typ reflect.Type

}{

{"openai", reflect.TypeOf(codersdk.ChatModelOpenAIProviderOptions{})},

{"anthropic", reflect.TypeOf(codersdk.ChatModelAnthropicProviderOptions{})},

{"google", reflect.TypeOf(codersdk.ChatModelGoogleProviderOptions{})},

{"openaicompat", reflect.TypeOf(codersdk.ChatModelOpenAICompatProviderOptions{})},

{"openrouter", reflect.TypeOf(codersdk.ChatModelOpenRouterProviderOptions{})},

{"vercel", reflect.TypeOf(codersdk.ChatModelVercelProviderOptions{})},

}

for _, p := range providerTypes {

schema.Providers[p.key] = extractFields(p.typ, "", nil, nil)

if err := validateFieldReferences(p.key, schema.Providers[p.key]); err != nil {

_, _ = fmt.Fprintln(os.Stderr, err)

os.Exit(1)

}

}

if err := validateProviderScopes(schema); err != nil {

_, _ = fmt.Fprintln(os.Stderr, err)

os.Exit(1)

}

out, err := json.MarshalIndent(schema, "", "\t")

if err != nil {

_, _ = fmt.Fprintf(os.Stderr, "marshal schema: %v\n", err)

os.Exit(1)

}

// Print the generated header and JSON body.

_, _ = fmt.Println("// Code generated by scripts/modeloptionsgen. DO NOT EDIT.")

_, _ = fmt.Println(string(out))

}

// validateProviderScopes rejects a providers tag naming something that is

// neither a canonical provider nor an alias, which would silently hide the

// field from every editor.

func validateProviderScopes(schema Schema) error {

for _, f := range schema.General.Fields {

for _, provider := range f.VisibleForProviders {

if _, ok := schema.Providers[provider]; ok {

continue

}

if _, ok := schema.ProviderAliases[provider]; ok {

continue

}

return xerrors.Errorf("field %q has providers entry %q referencing an unknown provider", f.JSONName, provider)

}

}

return nil

}

func validateFieldReferences(group string, fg FieldGroup) error {

names := make(map[string]bool, len(fg.Fields))

for _, f := range fg.Fields {

names[f.JSONName] = true

}

for _, f := range fg.Fields {

if f.VisibleWhen != "" && !names[f.VisibleWhen] {

return xerrors.Errorf("field %q in group %q has visible_when=%q referencing an unknown sibling field", f.JSONName, group, f.VisibleWhen)

}

for _, sibling := range f.ConflictsWith {

if !names[sibling] {

return xerrors.Errorf("field %q in group %q has conflicts_with entry %q referencing an unknown sibling field", f.JSONName, group, sibling)

}

}

}

return nil

}

// Nested fields inherit an enclosing provider scope unless they declare their

// own.

func extractFields(t reflect.Type, prefix string, skip map[string]bool, providers []string) FieldGroup {

var fields []SchemaField

for i := range t.NumField() {

f := t.Field(i)

if skip != nil && skip[f.Name] {

continue

}

jsonTag := f.Tag.Get("json")

if jsonTag == "" || jsonTag == "-" {

continue

}

jsonName := strings.Split(jsonTag, ",")[0]

if jsonName == "" {

continue

}

fullJSONName := jsonName

if prefix != "" {

fullJSONName = prefix + "." + jsonName

}

// Determine the underlying type, dereferencing pointers.

ft := f.Type

if ft.Kind() == reflect.Ptr {

ft = ft.Elem()

}

// Check the hidden tag before recursing into nested structs

// so that entire sub-objects can be marked hidden.

hidden := f.Tag.Get("hidden") == "true"

fieldProviders := providers

if tag := f.Tag.Get("providers"); tag != "" {

fieldProviders = strings.Split(tag, ",")

}

// decimal.Decimal is an opaque numeric type used for pricing

// precision; do not recurse into its internal struct fields.

isDecimal := ft == reflect.TypeOf(decimal.Decimal{})

// If the field is a struct (not a map), recurse to flatten

// its children using dot-separated names — unless the

// entire struct is marked hidden, in which case emit it

// as a single opaque field.

if ft.Kind() == reflect.Struct && !hidden && !isDecimal {

nested := extractFields(ft, fullJSONName, nil, fieldProviders)

fields = append(fields, nested.Fields...)

continue

}

typeName := goTypeToSchemaType(f.Type)

description := f.Tag.Get("description")

label := f.Tag.Get("label")

enumTag := f.Tag.Get("enum")

visibleWhen := f.Tag.Get("visible_when")

var conflictsWith []string

if conflictsTag := f.Tag.Get("conflicts_with"); conflictsTag != "" {

conflictsWith = strings.Split(conflictsTag, ",")

}

var enumValues []string

if enumTag != "" {

enumValues = strings.Split(enumTag, ",")

}

required := !strings.Contains(jsonTag, "omitempty")

inputType := inferInputType(typeName, enumValues)

fields = append(fields, SchemaField{

JSONName: fullJSONName,

GoName: goFieldPath(prefix, f.Name, t, fullJSONName),

Type: typeName,

Description: description,

Label: label,

Required: required,

Enum: enumValues,

InputType: inputType,

Hidden: hidden,

VisibleWhen: visibleWhen,

ConflictsWith: conflictsWith,

VisibleForProviders: fieldProviders,

})

}

return FieldGroup{Fields: fields}

}

// goFieldPath builds a dot-separated Go field name for nested fields.

// For top-level fields it returns just the field name. For nested

// fields it reconstructs the parent struct field name from the prefix

// by looking at the enclosing type's fields.

func goFieldPath(prefix, name string, _ reflect.Type, fullJSONName string) string {

if prefix == "" {

return name

}

// Build the Go path by walking the JSON name segments. Each

// segment maps to a struct field that we already traversed

// during recursion, so we reconstruct the path from the JSON

// parts. The parent extractFields call sets the prefix to the

// parent json name, so we can derive the Go path from the

// json segments by title-casing each part.

parts := strings.Split(fullJSONName, ".")

goNames := make([]string, 0, len(parts))

for _, p := range parts {

goNames = append(goNames, jsonSegmentToGoName(p))

}

return strings.Join(goNames, ".")

}

// jsonSegmentToGoName converts a snake_case JSON segment to a

// PascalCase Go field name using common conventions.

func jsonSegmentToGoName(seg string) string {

words := strings.Split(seg, "_")

var b strings.Builder

for _, w := range words {

if w == "" {

continue

}

// Handle common acronyms.

upper := strings.ToUpper(w)

switch upper {

case "ID", "URL", "IP", "HTTP", "JSON", "API", "UI":

_, _ = b.WriteString(upper)

default:

_, _ = b.WriteString(strings.ToUpper(w[:1]))

_, _ = b.WriteString(w[1:])

}

}

return b.String()

}

// goTypeToSchemaType maps a Go reflect.Type to a JSON schema type

// string.

func goTypeToSchemaType(t reflect.Type) string {

// Dereference pointers.

for t.Kind() == reflect.Ptr {

t = t.Elem()

}

// decimal.Decimal represents a precise numeric value and should

// map to the "number" schema type.

if t == reflect.TypeOf(decimal.Decimal{}) {

return "number"

}

switch t.Kind() {

case reflect.String:

return "string"

case reflect.Bool:

return "boolean"

case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:

return "integer"

case reflect.Float32, reflect.Float64:

return "number"

case reflect.Slice:

return "array"

case reflect.Map:

return "object"

default:

return "string"

}

}

// inferInputType decides the appropriate frontend input widget for

// a field based on its schema type and enum values.

func inferInputType(typeName string, enum []string) string {

if len(enum) > 0 {

return "select"

}

switch typeName {

case "boolean":

return "select"

case "array", "object":

return "json"

default:

return "input"

}

}