Add GPU fallback support via unified compute field (#65)

## Summary

`compute` now accepts either a single value or an array in
`cerebrium.toml`:

```toml
compute = "HOPPER_H100"                                       # single
compute = ["HOPPER_H100", "HOPPER_H200", "AMPERE_A100_80GB"]  # multiple
```

It's just a list of acceptable compute types. The CLI keeps a single
polymorphic field internally and forwards the values on deploy.

## Changes

- `config.go`: `Compute` is a single `ComputeField` (`[]string`) with
`Primary()` / `IsSet()` / `String()` helpers. The deploy payload always
  sends `compute` as an array.
- `loader.go`: parses either a string or an array into `ComputeField`,
  rejecting empty strings/arrays and non-string elements.
- Deploy summary shows a single `Compute:` row listing all values, and
shows
  GPU count whenever it's set.
- `run.go`: the run path still sends a single compute value, as that
endpoint
  takes one string.

## Backward compatible

- `compute = "HOPPER_H100"` (string) behaves exactly as before.
- Omitting `compute` is unchanged — a CPU deployment with the usual
defaults.

## Test plan

- [x] All tests pass (`go test ./...`)
- [x] Deployed to dev with array syntax
- [x] Deployed to dev with string syntax (backward compat)
- [x] Deployed to dev with no compute set (default behavior)

🤖 Generated with [Claude Code](https://claude.com/claude-code)

---------

Co-authored-by: Jonathan Irwin <jonoirwinrsa@gmail.com>
Co-authored-by: Cursor <cursoragent@cursor.com>
Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: 4 people

go.mod

@@ -9,7 +9,9 @@ require (
 	github.com/charmbracelet/bubbles v0.21.0
 	github.com/charmbracelet/bubbletea v1.3.10
 	github.com/charmbracelet/lipgloss v1.1.0
+	github.com/go-viper/mapstructure/v2 v2.4.0
 	github.com/golang-jwt/jwt/v5 v5.3.0
+	github.com/gorilla/websocket v1.5.3
 	github.com/hashicorp/go-version v1.7.0
 	github.com/mattn/go-isatty v0.0.20
 	github.com/muesli/termenv v0.16.0
@@ -34,9 +36,7 @@ require (
 	github.com/davecgh/go-spew v1.1.1 // indirect
 	github.com/erikgeiser/coninput v0.0.0-20211004153227-1c3628e74d0f // indirect
 	github.com/fsnotify/fsnotify v1.9.0 // indirect
-	github.com/go-viper/mapstructure/v2 v2.4.0 // indirect
 	github.com/google/uuid v1.6.0 // indirect
-	github.com/gorilla/websocket v1.5.3 // indirect
 	github.com/inconshreveable/mousetrap v1.1.0 // indirect
 	github.com/kardianos/osext v0.0.0-20190222173326-2bc1f35cddc0 // indirect
 	github.com/lucasb-eyer/go-colorful v1.3.0 // indirect

internal/ui/commands/deploy.go

@@ -121,14 +121,14 @@ func NewDeployView(ctx context.Context, conf DeployConfig) *DeployView {
 	ctx, cancel := context.WithCancel(ctx)
 
 	return &DeployView{
-		ctx:             ctx,
-		ctxCancel:       cancel,
-		state:           initialState,
-		isPartnerDeploy: isPartnerDeploy,
-		spinner:         ui.NewSpinner(),
-		progressBar:     prog,
+		ctx:                 ctx,
+		ctxCancel:           cancel,
+		state:               initialState,
+		isPartnerDeploy:     isPartnerDeploy,
+		spinner:             ui.NewSpinner(),
+		progressBar:         prog,
 		atomicBytesUploaded: &atomic.Int64{},
-		conf:            conf,
+		conf:                conf,
 	}
 }
 
@@ -1401,16 +1401,16 @@ func (m *DeployView) renderDeploymentSummary() string {
 
 		// HARDWARE PARAMETERS
 		var hardwareItems []string
-		if m.conf.Config.Hardware.Compute != nil {
-			hardwareItems = append(hardwareItems, fmt.Sprintf("Compute: %s", *m.conf.Config.Hardware.Compute))
+		if m.conf.Config.Hardware.Compute.IsSet() {
+			hardwareItems = append(hardwareItems, fmt.Sprintf("Compute: %s", m.conf.Config.Hardware.Compute))
 		}
 		if m.conf.Config.Hardware.CPU != nil {
 			hardwareItems = append(hardwareItems, fmt.Sprintf("CPU: %.1f", *m.conf.Config.Hardware.CPU))
 		}
 		if m.conf.Config.Hardware.Memory != nil {
 			hardwareItems = append(hardwareItems, fmt.Sprintf("Memory: %.0f GB", *m.conf.Config.Hardware.Memory))
 		}
-		if m.conf.Config.Hardware.GPUCount != nil && m.conf.Config.Hardware.Compute != nil && *m.conf.Config.Hardware.Compute != "CPU" {
+		if m.conf.Config.Hardware.GPUCount != nil {
 			hardwareItems = append(hardwareItems, fmt.Sprintf("GPU Count: %d", *m.conf.Config.Hardware.GPUCount))
 		}
 		if m.conf.Config.Hardware.Region != nil {
@@ -1469,7 +1469,7 @@ func (m *DeployView) renderDeploymentSummary() string {
 			concurrency := fmt.Sprintf("Replica Concurrency: %d", *m.conf.Config.Scaling.ReplicaConcurrency)
 
 			// Add GPU warning if applicable
-			if m.conf.Config.Hardware.Compute != nil && *m.conf.Config.Hardware.Compute != "CPU" && *m.conf.Config.Scaling.ReplicaConcurrency > 1 {
+			if m.conf.Config.Hardware.Compute.IsSet() && m.conf.Config.Hardware.Compute.Primary() != "CPU" && *m.conf.Config.Scaling.ReplicaConcurrency > 1 {
 				concurrency += " ⚠️  (Multiple concurrent requests on GPU)"
 			}
 			scalingItems = append(scalingItems, concurrency)
@@ -1549,16 +1549,16 @@ func (m *DeployView) renderDeploymentSummary() string {
 
 	// HARDWARE PARAMETERS
 	var hardwareRows []ui.TableRow
-	if m.conf.Config.Hardware.Compute != nil {
-		hardwareRows = append(hardwareRows, ui.TableRow{Label: "Compute:", Value: *m.conf.Config.Hardware.Compute})
+	if m.conf.Config.Hardware.Compute.IsSet() {
+		hardwareRows = append(hardwareRows, ui.TableRow{Label: "Compute:", Value: m.conf.Config.Hardware.Compute.String()})
 	}
 	if m.conf.Config.Hardware.CPU != nil {
 		hardwareRows = append(hardwareRows, ui.TableRow{Label: "CPU:", Value: fmt.Sprintf("%.1f", *m.conf.Config.Hardware.CPU)})
 	}
 	if m.conf.Config.Hardware.Memory != nil {
 		hardwareRows = append(hardwareRows, ui.TableRow{Label: "Memory:", Value: fmt.Sprintf("%.0f GB", *m.conf.Config.Hardware.Memory)})
 	}
-	if m.conf.Config.Hardware.GPUCount != nil && m.conf.Config.Hardware.Compute != nil && *m.conf.Config.Hardware.Compute != "CPU" {
+	if m.conf.Config.Hardware.GPUCount != nil {
 		hardwareRows = append(hardwareRows, ui.TableRow{Label: "GPU Count:", Value: fmt.Sprintf("%d", *m.conf.Config.Hardware.GPUCount)})
 	}
 	if m.conf.Config.Hardware.Region != nil {
@@ -1636,7 +1636,7 @@ func (m *DeployView) renderDeploymentSummary() string {
 		concurrency := fmt.Sprintf("%d", *m.conf.Config.Scaling.ReplicaConcurrency)
 
 		// Add GPU warning if applicable
-		if m.conf.Config.Hardware.Compute != nil && *m.conf.Config.Hardware.Compute != "CPU" && *m.conf.Config.Scaling.ReplicaConcurrency > 1 {
+		if m.conf.Config.Hardware.Compute.IsSet() && m.conf.Config.Hardware.Compute.Primary() != "CPU" && *m.conf.Config.Scaling.ReplicaConcurrency > 1 {
 			concurrency += " ⚠️  (Multiple concurrent requests on GPU)"
 		}
 		scalingRows = append(scalingRows, ui.TableRow{Label: "Replica Concurrency:", Value: concurrency})

internal/ui/commands/deploy_test.go

@@ -128,7 +128,6 @@ func TestDeployView(t *testing.T) {
 		mockClient := apimock.NewMockClient(t)
 
 		// Create a comprehensive config to test the display
-		compute := "NVIDIA_A10"
 		cpu := 2.0
 		memory := 8.0
 		gpuCount := 1
@@ -147,7 +146,7 @@ func TestDeployView(t *testing.T) {
 				Exclude:       []string{"__pycache__", "*.pyc"},
 			},
 			Hardware: projectconfig.HardwareConfig{
-				Compute:  &compute,
+				Compute:  projectconfig.ComputeField{"NVIDIA_A10"},
 				CPU:      &cpu,
 				Memory:   &memory,
 				GPUCount: &gpuCount,

internal/ui/commands/run.go

@@ -617,8 +617,8 @@ func (m *RunView) prepareRun() tea.Msg {
 	hardwareInfo := ""
 	if m.conf.Config != nil {
 		var info []string
-		if m.conf.Config.Hardware.Compute != nil && *m.conf.Config.Hardware.Compute != "" {
-			info = append(info, fmt.Sprintf("Compute: %s", *m.conf.Config.Hardware.Compute))
+		if m.conf.Config.Hardware.Compute.IsSet() {
+			info = append(info, fmt.Sprintf("Compute: %s", m.conf.Config.Hardware.Compute.Primary()))
 		}
 		if m.conf.Config.Hardware.GPUCount != nil && *m.conf.Config.Hardware.GPUCount > 0 {
 			info = append(info, fmt.Sprintf("GPU: %d", *m.conf.Config.Hardware.GPUCount))
@@ -848,8 +848,8 @@ func (m *RunView) uploadRun() tea.Msg {
 	// Build hardware config
 	hardwareConfig := make(map[string]any)
 	if m.conf.Config != nil {
-		if m.conf.Config.Hardware.Compute != nil && *m.conf.Config.Hardware.Compute != "" {
-			hardwareConfig["computeType"] = *m.conf.Config.Hardware.Compute
+		if m.conf.Config.Hardware.Compute.IsSet() {
+			hardwareConfig["computeType"] = m.conf.Config.Hardware.Compute.Primary()
 		}
 		if m.conf.Config.Hardware.GPUCount != nil && *m.conf.Config.Hardware.GPUCount > 0 {
 			hardwareConfig["gpuCount"] = *m.conf.Config.Hardware.GPUCount

pkg/projectconfig/config.go

@@ -1,5 +1,7 @@
 package projectconfig
 
+import "strings"
+
 // ProjectConfig represents the complete cerebrium.toml configuration
 type ProjectConfig struct {
 	Deployment     DeploymentConfig      `mapstructure:"deployment" toml:"deployment"`
@@ -30,12 +32,36 @@ type DeploymentConfig struct {
 
 // HardwareConfig represents the [cerebrium.hardware] section
 type HardwareConfig struct {
-	CPU      *float64 `mapstructure:"cpu" toml:"cpu,omitempty"`
-	Memory   *float64 `mapstructure:"memory" toml:"memory,omitempty"`
-	Compute  *string  `mapstructure:"compute" toml:"compute,omitempty"`
-	GPUCount *int     `mapstructure:"gpu_count" toml:"gpu_count,omitempty"`
-	Provider *string  `mapstructure:"provider" toml:"provider,omitempty"`
-	Region   *string  `mapstructure:"region" toml:"region,omitempty"`
+	CPU      *float64     `mapstructure:"cpu" toml:"cpu,omitempty"`
+	Memory   *float64     `mapstructure:"memory" toml:"memory,omitempty"`
+	Compute  ComputeField `mapstructure:"compute" toml:"compute,omitempty"`
+	GPUCount *int         `mapstructure:"gpu_count" toml:"gpu_count,omitempty"`
+	Provider *string      `mapstructure:"provider" toml:"provider,omitempty"`
+	Region   *string      `mapstructure:"region" toml:"region,omitempty"`
+}
+
+// ComputeField holds the list of acceptable compute types. It accepts either a
+// single value (`compute = "HOPPER_H100"`) or an array
+// (`compute = ["HOPPER_H100", "HOPPER_H200"]`) in cerebrium.toml.
+type ComputeField []string
+
+// Primary returns the requested compute type, or "" when unset.
+func (c ComputeField) Primary() string {
+	if len(c) == 0 {
+		return ""
+	}
+	return c[0]
+}
+
+// IsSet reports whether compute was configured in any form.
+func (c ComputeField) IsSet() bool {
+	return len(c) > 0
+}
+
+// String renders the configured compute types as a comma-separated list for
+// display, e.g. "HOPPER_H100, HOPPER_H200".
+func (c ComputeField) String() string {
+	return strings.Join(c, ", ")
 }
 
 // ScalingConfig represents the [cerebrium.scaling] section
@@ -121,10 +147,11 @@ func (pc *ProjectConfig) ToPayload() map[string]any {
 	if pc.Hardware.Memory != nil {
 		payload["memory"] = *pc.Hardware.Memory
 	}
-	if pc.Hardware.Compute != nil {
-		payload["compute"] = *pc.Hardware.Compute
+	if pc.Hardware.Compute.IsSet() {
+		// Always send the full list of compute types.
+		payload["compute"] = []string(pc.Hardware.Compute)
 	}
-	if pc.Hardware.GPUCount != nil && pc.Hardware.Compute != nil && *pc.Hardware.Compute != "CPU" {
+	if pc.Hardware.GPUCount != nil && pc.Hardware.Compute.IsSet() && pc.Hardware.Compute.Primary() != "CPU" {
 		payload["gpuCount"] = *pc.Hardware.GPUCount
 	}
 	if pc.Hardware.Provider != nil {

pkg/projectconfig/loader.go

@@ -3,7 +3,9 @@ package projectconfig
 import (
 	"fmt"
 	"os"
+	"reflect"
 
+	"github.com/go-viper/mapstructure/v2"
 	"github.com/spf13/viper"
 )
 
@@ -46,9 +48,15 @@ func Load(configPath string) (*ProjectConfig, error) {
 		return nil, fmt.Errorf("failed to parse deployment config: %w", err)
 	}
 
-	// Parse hardware section
+	// Parse hardware section.
+	// The compute decode hook lets `compute` accept either a scalar or an array
+	// without leaking that polymorphism into the rest of the codebase. Hardware
+	// has no duration or comma-slice fields, so viper's default hooks aren't
+	// needed here.
 	if v.IsSet("cerebrium.hardware") {
-		if err := v.UnmarshalKey("cerebrium.hardware", &config.Hardware); err != nil {
+		if err := v.UnmarshalKey("cerebrium.hardware", &config.Hardware,
+			viper.DecodeHook(computeFieldDecodeHook()),
+		); err != nil {
 			return nil, fmt.Errorf("failed to parse hardware config: %w", err)
 		}
 	}
@@ -130,6 +138,41 @@ func Load(configPath string) (*ProjectConfig, error) {
 	return &config, nil
 }
 
+// computeFieldDecodeHook teaches mapstructure how to read the polymorphic
+// `compute` field. Without it viper would refuse to decode a TOML scalar into
+// the ComputeField slice type. Rejects empty strings so downstream code can
+// rely on `IsSet() => Primary() != ""`.
+func computeFieldDecodeHook() mapstructure.DecodeHookFunc {
+	computeFieldType := reflect.TypeOf(ComputeField{})
+	return func(_ reflect.Type, to reflect.Type, data any) (any, error) {
+		if to != computeFieldType {
+			return data, nil
+		}
+		switch v := data.(type) {
+		case string:
+			if v == "" {
+				return nil, fmt.Errorf("compute must not be empty")
+			}
+			return ComputeField{v}, nil
+		case []any:
+			if len(v) == 0 {
+				return nil, fmt.Errorf("compute array must not be empty")
+			}
+			out := make(ComputeField, len(v))
+			for i, item := range v {
+				s, ok := item.(string)
+				if !ok || s == "" {
+					return nil, fmt.Errorf("compute values must be non-empty strings")
+				}
+				out[i] = s
+			}
+			return out, nil
+		default:
+			return nil, fmt.Errorf("compute must be a string or array of strings")
+		}
+	}
+}
+
 // applyDefaults sets default values for CLI-only fields that weren't specified in the config.
 // Payload fields (pythonVersion, baseImage, provider, region, scaling, auth, entrypoint,
 // port, healthcheck, etc.) are deliberately left unset so the backend can apply its own defaults.

pkg/projectconfig/loader_test.go

@@ -208,3 +208,95 @@ name = "test-app"
 		assert.Contains(t, err.Error(), "'cerebrium' key not found")
 	})
 }
+
+func TestLoad_Compute(t *testing.T) {
+	const header = `[cerebrium.deployment]
+name = "test-app"
+
+[cerebrium.hardware]
+`
+
+	write := func(t *testing.T, body string) string {
+		t.Helper()
+		path := filepath.Join(t.TempDir(), "cerebrium.toml")
+		require.NoError(t, os.WriteFile(path, []byte(header+body), 0644))
+		return path
+	}
+
+	t.Run("scalar form populates primary only", func(t *testing.T) {
+		cfg, err := Load(write(t, `compute = "HOPPER_H100"`))
+		require.NoError(t, err)
+		assert.Equal(t, ComputeField{"HOPPER_H100"}, cfg.Hardware.Compute)
+		assert.Equal(t, "HOPPER_H100", cfg.Hardware.Compute.Primary())
+		assert.True(t, cfg.Hardware.Compute.IsSet())
+	})
+
+	t.Run("array form preserves order", func(t *testing.T) {
+		cfg, err := Load(write(t, `compute = ["HOPPER_H100", "HOPPER_H200", "AMPERE_A100_80GB"]`))
+		require.NoError(t, err)
+		assert.Equal(t, ComputeField{"HOPPER_H100", "HOPPER_H200", "AMPERE_A100_80GB"}, cfg.Hardware.Compute)
+		assert.Equal(t, "HOPPER_H100", cfg.Hardware.Compute.Primary())
+	})
+
+	t.Run("single-element array behaves like scalar", func(t *testing.T) {
+		cfg, err := Load(write(t, `compute = ["HOPPER_H100"]`))
+		require.NoError(t, err)
+		assert.Equal(t, ComputeField{"HOPPER_H100"}, cfg.Hardware.Compute)
+		assert.Equal(t, "HOPPER_H100", cfg.Hardware.Compute.Primary())
+	})
+
+	t.Run("missing compute leaves field empty", func(t *testing.T) {
+		cfg, err := Load(write(t, ``))
+		require.NoError(t, err)
+		assert.False(t, cfg.Hardware.Compute.IsSet())
+		assert.Equal(t, "", cfg.Hardware.Compute.Primary())
+	})
+
+	t.Run("empty array is rejected", func(t *testing.T) {
+		_, err := Load(write(t, `compute = []`))
+		require.Error(t, err)
+		assert.Contains(t, err.Error(), "compute array must not be empty")
+	})
+
+	t.Run("empty string is rejected", func(t *testing.T) {
+		_, err := Load(write(t, `compute = ""`))
+		require.Error(t, err)
+		assert.Contains(t, err.Error(), "compute must not be empty")
+	})
+
+	t.Run("non-string element is rejected", func(t *testing.T) {
+		_, err := Load(write(t, `compute = ["HOPPER_H100", 42]`))
+		require.Error(t, err)
+		assert.Contains(t, err.Error(), "compute values must be non-empty strings")
+	})
+
+	t.Run("wrong type is rejected", func(t *testing.T) {
+		_, err := Load(write(t, `compute = 42`))
+		require.Error(t, err)
+		assert.Contains(t, err.Error(), "compute must be a string or array of strings")
+	})
+}
+
+func TestToPayload_Compute(t *testing.T) {
+	t.Run("scalar form sends single-element array", func(t *testing.T) {
+		pc := &ProjectConfig{
+			Deployment: DeploymentConfig{Name: "x"},
+			Hardware:   HardwareConfig{Compute: ComputeField{"HOPPER_H100"}},
+		}
+		assert.Equal(t, []string{"HOPPER_H100"}, pc.ToPayload()["compute"])
+	})
+
+	t.Run("multi-element form sends array", func(t *testing.T) {
+		pc := &ProjectConfig{
+			Deployment: DeploymentConfig{Name: "x"},
+			Hardware:   HardwareConfig{Compute: ComputeField{"HOPPER_H100", "HOPPER_H200"}},
+		}
+		assert.Equal(t, []string{"HOPPER_H100", "HOPPER_H200"}, pc.ToPayload()["compute"])
+	})
+
+	t.Run("unset compute is omitted", func(t *testing.T) {
+		pc := &ProjectConfig{Deployment: DeploymentConfig{Name: "x"}}
+		_, present := pc.ToPayload()["compute"]
+		assert.False(t, present)
+	})
+}

pkg/projectconfig/validator.go

@@ -40,7 +40,7 @@ func Validate(config *ProjectConfig) error {
 	}
 
 	// Default gpu_count to 1 if compute is set but gpu_count is not
-	if config.Hardware.Compute != nil && *config.Hardware.Compute != "CPU" {
+	if config.Hardware.Compute.IsSet() && config.Hardware.Compute.Primary() != "CPU" {
 		if config.Hardware.GPUCount == nil {
 			defaultGPUCount := 1
 			config.Hardware.GPUCount = &defaultGPUCount