Preserve HTTP API proxy target schemes

Co-authored-by: pelikhan <4175913+pelikhan@users.noreply.github.com>

Author: Copilot

pkg/constants/version_constants.go

@@ -176,6 +176,10 @@ const AWFAPIProxyCACertMinVersion Version = "v0.28.10"
 // network.verifySbxEgress for fail-closed Docker sbx egress verification.
 const AWFVerifySbxEgressMinVersion Version = "v0.28.13"
 
+// AWFHTTPAPITargetMinVersion is the minimum AWF version that supports explicit
+// http:// schemes in apiProxy target hosts.
+const AWFHTTPAPITargetMinVersion Version = "v0.28.13"
+
 // DefaultGVisorVersion is the pinned gVisor release used by the compiler-generated
 // install step. A specific dated release name is used instead of "latest" to ensure
 // reproducible, verifiable installs. Each release provides SHA-512 files for

pkg/workflow/awf_config_build.go

@@ -26,7 +26,7 @@ var awfConfigLog = logger.New("workflow:awf_config")
 //
 // The caller is responsible for writing the returned JSON to disk at the path expected
 // by the AWF --config flag. See BuildAWFCommand for how this is wired together.
-func BuildAWFConfigJSON(config AWFCommandConfig) (string, error) {
+func BuildAWFConfigJSON(config AWFCommandConfig) (string, error) { //nolint:largefunc // Assembles the full AWF config by section.
 	awfConfigLog.Printf("Building AWF config JSON: engine=%s, allowed_domains=%q", config.EngineName, config.AllowedDomains)
 
 	// Resolve firewall config once — used for both the schema URL and the container image tag.
@@ -191,11 +191,11 @@ func BuildAWFConfigJSON(config AWFCommandConfig) (string, error) {
 
 	targets := map[string]*AWFAPITargetConfig{}
 
-	if openaiTarget := extractAPITargetHost(config.WorkflowData, "OPENAI_BASE_URL"); openaiTarget != "" {
+	if openaiTarget := extractAPIProxyTargetHost(config.WorkflowData, "OPENAI_BASE_URL", firewallConfig); openaiTarget != "" {
 		targets["openai"] = &AWFAPITargetConfig{Host: openaiTarget}
 		awfConfigLog.Printf("API proxy: custom openai target=%s", openaiTarget)
 	}
-	if anthropicTarget := extractAPITargetHost(config.WorkflowData, "ANTHROPIC_BASE_URL"); anthropicTarget != "" {
+	if anthropicTarget := extractAPIProxyTargetHost(config.WorkflowData, "ANTHROPIC_BASE_URL", firewallConfig); anthropicTarget != "" {
 		targets["anthropic"] = &AWFAPITargetConfig{Host: anthropicTarget}
 		awfConfigLog.Printf("API proxy: custom anthropic target=%s", anthropicTarget)
 	}
@@ -246,7 +246,11 @@ func BuildAWFConfigJSON(config AWFCommandConfig) (string, error) {
 			awfConfigLog.Printf("API proxy: copilot sessionId configured")
 		}
 	}
-	if geminiTarget := GetGeminiAPITarget(config.WorkflowData, config.EngineName); geminiTarget != "" {
+	geminiTarget := extractAPIProxyTargetHost(config.WorkflowData, "GEMINI_API_BASE_URL", firewallConfig)
+	if geminiTarget == "" {
+		geminiTarget = GetGeminiAPITarget(config.WorkflowData, config.EngineName)
+	}
+	if geminiTarget != "" {
 		awfConfigLog.Printf("API proxy: custom gemini target=%s", geminiTarget)
 		targets["gemini"] = &AWFAPITargetConfig{Host: geminiTarget}
 	}

pkg/workflow/awf_config_test.go

@@ -388,6 +388,97 @@ func TestBuildAWFConfigJSON(t *testing.T) {
 		assert.Contains(t, jsonStr, "my-proxy.internal.example.com", "should include the openai host")
 	})
 
+	t.Run("HTTP API target schemes follow the effective AWF version", func(t *testing.T) {
+		tests := []struct {
+			name         string
+			engine       string
+			envVar       string
+			baseURL      string
+			version      string
+			provider     string
+			expectedHost string
+		}{
+			{
+				name:         "openai preserves HTTP with the default AWF version",
+				engine:       "codex",
+				envVar:       "OPENAI_BASE_URL",
+				baseURL:      "http://openai-gateway.example.com/v1",
+				provider:     "openai",
+				expectedHost: "http://openai-gateway.example.com",
+			},
+			{
+				name:         "anthropic preserves HTTP at the minimum AWF version",
+				engine:       "claude",
+				envVar:       "ANTHROPIC_BASE_URL",
+				baseURL:      "http://anthropic-gateway.example.com/v1",
+				version:      string(constants.AWFHTTPAPITargetMinVersion),
+				provider:     "anthropic",
+				expectedHost: "http://anthropic-gateway.example.com",
+			},
+			{
+				name:         "gemini preserves HTTP with a newer AWF version",
+				engine:       "gemini",
+				envVar:       "GEMINI_API_BASE_URL",
+				baseURL:      "http://gemini-gateway.example.com/v1",
+				version:      "v0.28.14",
+				provider:     "gemini",
+				expectedHost: "http://gemini-gateway.example.com",
+			},
+			{
+				name:         "older AWF versions keep HTTP targets bare",
+				engine:       "codex",
+				envVar:       "OPENAI_BASE_URL",
+				baseURL:      "http://legacy-gateway.example.com/v1",
+				version:      "v0.28.12",
+				provider:     "openai",
+				expectedHost: "legacy-gateway.example.com",
+			},
+			{
+				name:         "HTTPS targets remain bare",
+				engine:       "claude",
+				envVar:       "ANTHROPIC_BASE_URL",
+				baseURL:      "https://secure-gateway.example.com/v1",
+				provider:     "anthropic",
+				expectedHost: "secure-gateway.example.com",
+			},
+			{
+				name:         "bare targets remain bare",
+				engine:       "gemini",
+				envVar:       "GEMINI_API_BASE_URL",
+				baseURL:      "bare-gateway.example.com/v1",
+				provider:     "gemini",
+				expectedHost: "bare-gateway.example.com",
+			},
+		}
+
+		for _, tt := range tests {
+			t.Run(tt.name, func(t *testing.T) {
+				config := AWFCommandConfig{
+					EngineName:     tt.engine,
+					AllowedDomains: "github.com",
+					WorkflowData: &WorkflowData{
+						EngineConfig: &EngineConfig{
+							ID:  tt.engine,
+							Env: map[string]string{tt.envVar: tt.baseURL},
+						},
+						NetworkPermissions: &NetworkPermissions{
+							Firewall: &FirewallConfig{Enabled: true, Version: tt.version},
+						},
+					},
+				}
+
+				jsonStr, err := BuildAWFConfigJSON(config)
+				require.NoError(t, err)
+
+				var parsed AWFConfigFile
+				require.NoError(t, json.Unmarshal([]byte(jsonStr), &parsed))
+				require.NotNil(t, parsed.APIProxy)
+				require.Contains(t, parsed.APIProxy.Targets, tt.provider)
+				assert.Equal(t, tt.expectedHost, parsed.APIProxy.Targets[tt.provider].Host)
+			})
+		}
+	})
+
 	t.Run("default max-ai-credits is enabled when frontmatter is unset", func(t *testing.T) {
 		config := AWFCommandConfig{
 			EngineName:     "copilot",

pkg/workflow/awf_feature_flags.go

@@ -109,6 +109,12 @@ func awfSupportsVerifySbxEgress(firewallConfig *FirewallConfig) bool {
 	return awfVersionAtLeast(firewallConfig, constants.AWFVerifySbxEgressMinVersion)
 }
 
+// awfSupportsHTTPAPITargets returns true when the effective AWF version supports
+// explicit http:// schemes in apiProxy target hosts.
+func awfSupportsHTTPAPITargets(firewallConfig *FirewallConfig) bool {
+	return awfVersionAtLeast(firewallConfig, constants.AWFHTTPAPITargetMinVersion)
+}
+
 // awfEmitsFilesystemAllowWrite reports whether the compiler may emit the
 // filesystem section of awf-config.json for this workflow.
 //

pkg/workflow/engine_api_targets.go

@@ -71,6 +71,20 @@ func extractAPITargetHost(workflowData *WorkflowData, envVar string) string {
 	return host
 }
 
+// extractAPIProxyTargetHost returns the target host format expected by the
+// effective AWF version, preserving an explicit http:// scheme when supported.
+func extractAPIProxyTargetHost(workflowData *WorkflowData, envVar string, firewallConfig *FirewallConfig) string {
+	host := extractAPITargetHost(workflowData, envVar)
+	if host == "" || !awfSupportsHTTPAPITargets(firewallConfig) {
+		return host
+	}
+
+	if strings.HasPrefix(workflowData.EngineConfig.Env[envVar], "http://") {
+		return "http://" + host
+	}
+	return host
+}
+
 // extractAPIBasePath extracts the path component from a custom API base URL in engine.env.
 // Returns the path prefix (e.g., "/serving-endpoints") or empty string if no path is present.
 // Root-only paths ("/") and empty paths return empty string.