Normalize automatic GPT image size

adapter/main.go

@@ -25,6 +25,7 @@ import (
 const (
 	defaultExternalPort    = "7860"
 	defaultInternalPort    = "3000"
+	defaultAutoImageSize   = "1024x1024"
 	maxImageResponseBytes  = 96 << 20
 	maxDownloadedImageSize = 64 << 20
 	imageDownloadTimeout   = 3 * time.Minute
@@ -64,6 +65,10 @@ func run() error {
 	if err != nil {
 		return err
 	}
+	autoImageSize, err := parseAutoImageSize(envOrDefault("IMAGE_AUTO_SIZE", defaultAutoImageSize))
+	if err != nil {
+		return err
+	}
 
 	child := exec.Command("/new-api")
 	child.Dir = "/data"
@@ -83,7 +88,7 @@ func run() error {
 
 	server := &http.Server{
 		Addr:              ":" + externalPort,
-		Handler:           newProxy(backend, newPublicImageClient(), defaultMode, maxConcurrency),
+		Handler:           newProxy(backend, newPublicImageClient(), defaultMode, maxConcurrency, autoImageSize),
 		ReadHeaderTimeout: 30 * time.Second,
 		IdleTimeout:       2 * time.Minute,
 	}
@@ -98,11 +103,12 @@ func run() error {
 	defer signal.Stop(signalCh)
 
 	log.Printf(
-		"image response adapter listening on :%s; New API on 127.0.0.1:%s; default=%s; max_concurrency=%d",
+		"image response adapter listening on :%s; New API on 127.0.0.1:%s; default=%s; max_concurrency=%d; auto_size=%s",
 		externalPort,
 		internalPort,
 		defaultMode,
 		maxConcurrency,
+		displayAutoImageSize(autoImageSize),
 	)
 
 	select {
@@ -132,6 +138,7 @@ func newProxy(
 	downloadClient *http.Client,
 	defaultMode imageResponseMode,
 	maxConcurrency int,
+	autoImageSize string,
 ) *httputil.ReverseProxy {
 	proxy := httputil.NewSingleHostReverseProxy(backend)
 	originalDirector := proxy.Director
@@ -139,6 +146,9 @@ func newProxy(
 		if isImageEndpoint(request.URL.Path) {
 			mode := imageResponseModeForRequest(request, defaultMode)
 			request.Header.Del(responseFormatHeader)
+			if normalizeAutoImageSize(request, autoImageSize) {
+				log.Printf("normalized auto image size to %s", autoImageSize)
+			}
 			requestWithMode := request.WithContext(context.WithValue(request.Context(), responseModeContextKey{}, mode))
 			*request = *requestWithMode
 		}
@@ -374,6 +384,52 @@ func imageResponseModeForRequest(request *http.Request, fallback imageResponseMo
 	return fallback
 }
 
+func normalizeAutoImageSize(request *http.Request, fallbackSize string) bool {
+	if request == nil || request.URL.Path != "/v1/images/generations" || request.Body == nil || fallbackSize == "" {
+		return false
+	}
+
+	body, complete := readAndRestoreRequestBody(request, maxModeRequestBody)
+	if !complete {
+		return false
+	}
+	var payload map[string]json.RawMessage
+	if err := json.Unmarshal(body, &payload); err != nil {
+		return false
+	}
+	model, ok := decodeNonEmptyString(payload["model"])
+	if !ok || !strings.HasPrefix(strings.ToLower(model), "gpt-image-") {
+		return false
+	}
+	size, hasSize := decodeNonEmptyString(payload["size"])
+	if hasSize && !strings.EqualFold(strings.TrimSpace(size), "auto") {
+		return false
+	}
+	encodedSize, err := json.Marshal(fallbackSize)
+	if err != nil {
+		return false
+	}
+	payload["size"] = encodedSize
+	updatedBody, err := json.Marshal(payload)
+	if err != nil {
+		return false
+	}
+	request.Body = io.NopCloser(bytes.NewReader(updatedBody))
+	request.ContentLength = int64(len(updatedBody))
+	request.Header.Set("Content-Length", strconv.Itoa(len(updatedBody)))
+	return true
+}
+
+func readAndRestoreRequestBody(request *http.Request, limit int64) ([]byte, bool) {
+	prefix, err := io.ReadAll(io.LimitReader(request.Body, limit+1))
+	request.Body = io.NopCloser(io.MultiReader(bytes.NewReader(prefix), request.Body))
+	if err != nil || int64(len(prefix)) > limit {
+		return nil, false
+	}
+	request.Body = io.NopCloser(bytes.NewReader(prefix))
+	return prefix, true
+}
+
 func imageResponseModeFromContext(ctx context.Context) imageResponseMode {
 	if mode, ok := ctx.Value(responseModeContextKey{}).(imageResponseMode); ok {
 		return mode
@@ -394,6 +450,31 @@ func parseImageResponseMode(raw string) (imageResponseMode, error) {
 	}
 }
 
+func parseAutoImageSize(raw string) (string, error) {
+	normalized := strings.ToLower(strings.TrimSpace(raw))
+	switch normalized {
+	case "off", "disabled", "passthrough":
+		return "", nil
+	}
+	parts := strings.Split(normalized, "x")
+	if len(parts) != 2 {
+		return "", fmt.Errorf("IMAGE_AUTO_SIZE must be WIDTHxHEIGHT or off")
+	}
+	width, widthErr := strconv.Atoi(parts[0])
+	height, heightErr := strconv.Atoi(parts[1])
+	if widthErr != nil || heightErr != nil || width < 1 || height < 1 {
+		return "", fmt.Errorf("IMAGE_AUTO_SIZE must be WIDTHxHEIGHT or off")
+	}
+	return strconv.Itoa(width) + "x" + strconv.Itoa(height), nil
+}
+
+func displayAutoImageSize(size string) string {
+	if size == "" {
+		return "off"
+	}
+	return size
+}
+
 func decodeNonEmptyString(raw json.RawMessage) (string, bool) {
 	if len(raw) == 0 || string(raw) == "null" {
 		return "", false

adapter/main_test.go

@@ -130,6 +130,58 @@ func TestImageResponseModeForRequest(t *testing.T) {
 	}
 }
 
+func TestNormalizeAutoImageSize(t *testing.T) {
+	tests := []struct {
+		name        string
+		body        string
+		fallback    string
+		wantChanged bool
+		wantSize    string
+	}{
+		{name: "auto", body: `{"model":"gpt-image-2","size":"auto","prompt":"test"}`, fallback: defaultAutoImageSize, wantChanged: true, wantSize: defaultAutoImageSize},
+		{name: "missing", body: `{"model":"gpt-image-2","prompt":"test"}`, fallback: defaultAutoImageSize, wantChanged: true, wantSize: defaultAutoImageSize},
+		{name: "explicit", body: `{"model":"gpt-image-2","size":"1536x1024"}`, fallback: defaultAutoImageSize, wantSize: "1536x1024"},
+		{name: "other model", body: `{"model":"dall-e-3","size":"auto"}`, fallback: defaultAutoImageSize, wantSize: "auto"},
+		{name: "disabled", body: `{"model":"gpt-image-2","size":"auto"}`, wantSize: "auto"},
+	}
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			request := httptest.NewRequest(http.MethodPost, "/v1/images/generations", strings.NewReader(test.body))
+			changed := normalizeAutoImageSize(request, test.fallback)
+			if changed != test.wantChanged {
+				t.Fatalf("changed=%v want=%v", changed, test.wantChanged)
+			}
+			var payload struct {
+				Size string `json:"size"`
+			}
+			if err := json.NewDecoder(request.Body).Decode(&payload); err != nil {
+				t.Fatal(err)
+			}
+			if payload.Size != test.wantSize {
+				t.Fatalf("size=%q want=%q", payload.Size, test.wantSize)
+			}
+		})
+	}
+}
+
+func TestParseAutoImageSize(t *testing.T) {
+	for raw, want := range map[string]string{
+		"1024x1024":   "1024x1024",
+		" 1536X1024 ": "1536x1024",
+		"off":         "",
+	} {
+		got, err := parseAutoImageSize(raw)
+		if err != nil || got != want {
+			t.Fatalf("parseAutoImageSize(%q)=%q, %v; want %q", raw, got, err, want)
+		}
+	}
+	for _, raw := range []string{"auto", "1024", "0x1024", "wide x tall"} {
+		if _, err := parseAutoImageSize(raw); err == nil {
+			t.Fatalf("parseAutoImageSize(%q) should fail", raw)
+		}
+	}
+}
+
 func TestAdaptImageResponseHonorsURLMode(t *testing.T) {
 	body := `{"data":[{"url":"https://cdn.example/image.png"}]}`
 	request := httptest.NewRequest(http.MethodPost, "/v1/images/generations", nil)
@@ -162,14 +214,22 @@ func TestProxyConvertsDefaultImageResponse(t *testing.T) {
 	defer imageServer.Close()
 
 	var forwardedOverride string
+	var forwardedSize string
 	backend := httptest.NewServer(http.HandlerFunc(func(writer http.ResponseWriter, request *http.Request) {
 		forwardedOverride = request.Header.Get(responseFormatHeader)
+		var payload struct {
+			Size string `json:"size"`
+		}
+		if err := json.NewDecoder(request.Body).Decode(&payload); err != nil {
+			t.Error(err)
+		}
+		forwardedSize = payload.Size
 		writer.Header().Set("Content-Type", "application/json")
 		_, _ = fmt.Fprintf(writer, `{"created":123,"data":[{"url":%q}]}`, imageServer.URL+"/image.png")
 	}))
 	defer backend.Close()
 
-	proxy := httptest.NewServer(newProxy(mustParseURL(t, backend.URL), imageServer.Client(), imageResponseModeBase64, 2))
+	proxy := httptest.NewServer(newProxy(mustParseURL(t, backend.URL), imageServer.Client(), imageResponseModeBase64, 2, defaultAutoImageSize))
 	defer proxy.Close()
 
 	request, err := http.NewRequest(http.MethodPost, proxy.URL+"/v1/images/generations", strings.NewReader(`{"model":"gpt-image-2"}`))
@@ -199,6 +259,9 @@ func TestProxyConvertsDefaultImageResponse(t *testing.T) {
 	if forwardedOverride != "" {
 		t.Fatalf("override header leaked upstream: %q", forwardedOverride)
 	}
+	if forwardedSize != defaultAutoImageSize {
+		t.Fatalf("forwarded size=%q want=%q", forwardedSize, defaultAutoImageSize)
+	}
 	if len(payload.Data) != 1 || payload.Data[0].URL != "" || payload.Data[0].B64JSON != base64.StdEncoding.EncodeToString(imageBytes) {
 		t.Fatalf("unexpected converted response: %+v", payload)
 	}
@@ -219,7 +282,7 @@ func TestProxyHonorsURLResponseFormat(t *testing.T) {
 	}))
 	defer backend.Close()
 
-	proxy := httptest.NewServer(newProxy(mustParseURL(t, backend.URL), imageServer.Client(), imageResponseModeBase64, 2))
+	proxy := httptest.NewServer(newProxy(mustParseURL(t, backend.URL), imageServer.Client(), imageResponseModeBase64, 2, defaultAutoImageSize))
 	defer proxy.Close()
 
 	response, err := proxy.Client().Post(
@@ -255,7 +318,7 @@ func TestProxyLeavesNonImageResponseUnchanged(t *testing.T) {
 	}))
 	defer backend.Close()
 
-	proxy := httptest.NewServer(newProxy(mustParseURL(t, backend.URL), http.DefaultClient, imageResponseModeBase64, 2))
+	proxy := httptest.NewServer(newProxy(mustParseURL(t, backend.URL), http.DefaultClient, imageResponseModeBase64, 2, defaultAutoImageSize))
 	defer proxy.Close()
 	response, err := proxy.Client().Post(proxy.URL+"/v1/responses", "application/json", strings.NewReader(`{"model":"gpt-5"}`))
 	if err != nil {
@@ -301,7 +364,7 @@ func TestProxyLimitsConcurrentImageDownloads(t *testing.T) {
 		_, _ = fmt.Fprintf(writer, `{"data":[{"url":%q}]}`, imageServer.URL+"/image.png")
 	}))
 	defer backend.Close()
-	proxy := httptest.NewServer(newProxy(mustParseURL(t, backend.URL), imageServer.Client(), imageResponseModeBase64, concurrency))
+	proxy := httptest.NewServer(newProxy(mustParseURL(t, backend.URL), imageServer.Client(), imageResponseModeBase64, concurrency, defaultAutoImageSize))
 	defer proxy.Close()
 
 	errors := make(chan error, requestCount)