Remove image response adapter

Dockerfile

@@ -1,20 +1,10 @@
-FROM golang:1.24-alpine AS adapter-builder
-
-WORKDIR /src/adapter
-COPY adapter/ ./
-RUN go test ./... && \
-    CGO_ENABLED=0 go build -trimpath -ldflags="-s -w" -o /out/image-response-adapter .
-
+# 使用官方正版镜像 (Calcium-Ion)
 FROM calciumion/new-api:latest
 
-ENV PORT=7860 \
-    INTERNAL_NEW_API_PORT=3000 \
-    IMAGE_RESPONSE_MODE=b64_json \
-    IMAGE_CONVERSION_MAX_CONCURRENCY=4
+# 设置 Hugging Face 要求的端口
+ENV PORT=7860
 EXPOSE 7860
 
+# 解决权限问题 (必须加，否则会报错无法写入数据库)
 USER root
-RUN mkdir -p /data && chmod 777 /data
-
-COPY --from=adapter-builder /out/image-response-adapter /image-response-adapter
-ENTRYPOINT ["/image-response-adapter"]
+RUN mkdir -p /data && chmod 777 /data

README.md

@@ -9,16 +9,3 @@ license: mit
 ---
 
 Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
-
-This Space runs the official New API image behind a small response adapter. All
-requests are proxied unchanged except successful `/v1/images/generations` and
-`/v1/images/edits` responses containing `data[].url` without `b64_json`. For
-those responses, the adapter downloads the public image URL and returns the
-official Base64 response shape expected by OpenAI-compatible clients.
-
-The default mode is `b64_json`. A caller that needs the original URL can set
-`response_format: "url"` in a JSON generation request or send
-`X-Image-Response-Format: url`. The custom header is removed before forwarding.
-Set `IMAGE_RESPONSE_MODE=url` to make URL passthrough the Space-wide default.
-`IMAGE_CONVERSION_MAX_CONCURRENCY` limits simultaneous URL downloads and
-defaults to `4` for CPU Basic hardware.

adapter/go.mod

@@ -1,3 +0,0 @@
-module new-api-image-response-adapter
-
-go 1.23

adapter/main.go

@@ -1,565 +0,0 @@
-package main
-
-import (
-	"bytes"
-	"context"
-	"encoding/base64"
-	"encoding/json"
-	"errors"
-	"fmt"
-	"io"
-	"log"
-	"net"
-	"net/http"
-	"net/http/httputil"
-	"net/url"
-	"os"
-	"os/exec"
-	"os/signal"
-	"strconv"
-	"strings"
-	"syscall"
-	"time"
-)
-
-const (
-	defaultExternalPort    = "7860"
-	defaultInternalPort    = "3000"
-	defaultAutoImageSize   = "1024x1024"
-	maxImageResponseBytes  = 96 << 20
-	maxDownloadedImageSize = 64 << 20
-	imageDownloadTimeout   = 3 * time.Minute
-	shutdownTimeout        = 15 * time.Second
-	defaultMaxConcurrency  = 4
-	maxModeRequestBody     = 1 << 20
-	responseFormatHeader   = "X-Image-Response-Format"
-)
-
-type imageDownloader func(context.Context, string) ([]byte, error)
-type imageResponseMode string
-
-const (
-	imageResponseModeBase64 imageResponseMode = "b64_json"
-	imageResponseModeURL    imageResponseMode = "url"
-)
-
-type responseModeContextKey struct{}
-
-func main() {
-	if err := run(); err != nil {
-		log.Fatal(err)
-	}
-}
-
-func run() error {
-	externalPort := envOrDefault("PORT", defaultExternalPort)
-	internalPort := envOrDefault("INTERNAL_NEW_API_PORT", defaultInternalPort)
-	if externalPort == internalPort {
-		return fmt.Errorf("PORT and INTERNAL_NEW_API_PORT must differ")
-	}
-	defaultMode, err := parseImageResponseMode(envOrDefault("IMAGE_RESPONSE_MODE", string(imageResponseModeBase64)))
-	if err != nil {
-		return err
-	}
-	maxConcurrency, err := envInt("IMAGE_CONVERSION_MAX_CONCURRENCY", defaultMaxConcurrency, 1, 32)
-	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"
-	child.Env = replaceEnv(os.Environ(), "PORT", internalPort)
-	child.Stdout = os.Stdout
-	child.Stderr = os.Stderr
-	child.Stdin = os.Stdin
-	if err := child.Start(); err != nil {
-		return fmt.Errorf("start New API: %w", err)
-	}
-
-	backend, err := url.Parse("http://127.0.0.1:" + internalPort)
-	if err != nil {
-		_ = child.Process.Kill()
-		return fmt.Errorf("parse internal New API URL: %w", err)
-	}
-
-	server := &http.Server{
-		Addr:              ":" + externalPort,
-		Handler:           newProxy(backend, newPublicImageClient(), defaultMode, maxConcurrency, autoImageSize),
-		ReadHeaderTimeout: 30 * time.Second,
-		IdleTimeout:       2 * time.Minute,
-	}
-
-	childDone := make(chan error, 1)
-	go func() { childDone <- child.Wait() }()
-	serverDone := make(chan error, 1)
-	go func() { serverDone <- server.ListenAndServe() }()
-
-	signalCh := make(chan os.Signal, 1)
-	signal.Notify(signalCh, syscall.SIGINT, syscall.SIGTERM)
-	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; auto_size=%s",
-		externalPort,
-		internalPort,
-		defaultMode,
-		maxConcurrency,
-		displayAutoImageSize(autoImageSize),
-	)
-
-	select {
-	case sig := <-signalCh:
-		log.Printf("received %s, shutting down", sig)
-		shutdownServer(server)
-		stopChild(child, childDone, sig)
-		return nil
-	case err := <-childDone:
-		shutdownServer(server)
-		if err == nil {
-			return errors.New("New API exited")
-		}
-		return fmt.Errorf("New API exited: %w", err)
-	case err := <-serverDone:
-		if err != nil && !errors.Is(err, http.ErrServerClosed) {
-			stopChild(child, childDone, syscall.SIGTERM)
-			return fmt.Errorf("adapter server: %w", err)
-		}
-		stopChild(child, childDone, syscall.SIGTERM)
-		return nil
-	}
-}
-
-func newProxy(
-	backend *url.URL,
-	downloadClient *http.Client,
-	defaultMode imageResponseMode,
-	maxConcurrency int,
-	autoImageSize string,
-) *httputil.ReverseProxy {
-	proxy := httputil.NewSingleHostReverseProxy(backend)
-	originalDirector := proxy.Director
-	proxy.Director = func(request *http.Request) {
-		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
-		}
-		originalDirector(request)
-	}
-	transport := http.DefaultTransport.(*http.Transport).Clone()
-	transport.DisableCompression = true
-	proxy.Transport = transport
-	proxy.FlushInterval = -1
-	conversionSlots := make(chan struct{}, maxConcurrency)
-	proxy.ModifyResponse = func(response *http.Response) error {
-		return adaptImageResponse(response, func(ctx context.Context, imageURL string) ([]byte, error) {
-			select {
-			case conversionSlots <- struct{}{}:
-				defer func() { <-conversionSlots }()
-			case <-ctx.Done():
-				return nil, ctx.Err()
-			}
-			return downloadImage(ctx, downloadClient, imageURL)
-		})
-	}
-	proxy.ErrorHandler = func(writer http.ResponseWriter, request *http.Request, err error) {
-		log.Printf("proxy request failed path=%q: %v", request.URL.Path, err)
-		if strings.HasPrefix(request.URL.Path, "/v1/") {
-			writer.Header().Set("Content-Type", "application/json")
-			writer.WriteHeader(http.StatusBadGateway)
-			_, _ = io.WriteString(writer, `{"error":{"message":"image response adaptation failed","type":"api_error"}}`)
-			return
-		}
-		http.Error(writer, "Bad gateway", http.StatusBadGateway)
-	}
-	return proxy
-}
-
-func adaptImageResponse(response *http.Response, downloader imageDownloader) error {
-	if response == nil || response.Request == nil || !isImageEndpoint(response.Request.URL.Path) {
-		return nil
-	}
-	if imageResponseModeFromContext(response.Request.Context()) == imageResponseModeURL {
-		return nil
-	}
-	if response.StatusCode < http.StatusOK || response.StatusCode >= http.StatusMultipleChoices {
-		return nil
-	}
-	contentType := strings.ToLower(response.Header.Get("Content-Type"))
-	if contentType != "" && !strings.Contains(contentType, "json") {
-		return nil
-	}
-
-	body, err := readLimited(response.Body, maxImageResponseBytes)
-	if err != nil {
-		return fmt.Errorf("read image response: %w", err)
-	}
-	converted, count, err := convertImageURLs(response.Request.Context(), body, downloader)
-	if err != nil {
-		return fmt.Errorf("convert image response: %w", err)
-	}
-	if count == 0 {
-		resetResponseBody(response, body)
-		return nil
-	}
-
-	resetResponseBody(response, converted)
-	response.Header.Set("Content-Type", "application/json")
-	response.Header.Del("Content-Encoding")
-	response.Header.Del("ETag")
-	log.Printf("converted %d image URL response item(s) to b64_json", count)
-	return nil
-}
-
-func convertImageURLs(ctx context.Context, body []byte, downloader imageDownloader) ([]byte, int, error) {
-	var envelope map[string]json.RawMessage
-	if err := json.Unmarshal(body, &envelope); err != nil {
-		return body, 0, nil
-	}
-	rawData, ok := envelope["data"]
-	if !ok {
-		return body, 0, nil
-	}
-
-	var data []map[string]json.RawMessage
-	if err := json.Unmarshal(rawData, &data); err != nil {
-		return body, 0, nil
-	}
-
-	converted := 0
-	for _, item := range data {
-		if nonEmptyJSONString(item["b64_json"]) {
-			continue
-		}
-		imageURL, ok := decodeNonEmptyString(item["url"])
-		if !ok {
-			continue
-		}
-		imageBytes, err := downloader(ctx, imageURL)
-		if err != nil {
-			return nil, 0, err
-		}
-		encoded, err := json.Marshal(base64.StdEncoding.EncodeToString(imageBytes))
-		if err != nil {
-			return nil, 0, fmt.Errorf("encode image data: %w", err)
-		}
-		item["b64_json"] = encoded
-		delete(item, "url")
-		converted++
-	}
-	if converted == 0 {
-		return body, 0, nil
-	}
-
-	updatedData, err := json.Marshal(data)
-	if err != nil {
-		return nil, 0, fmt.Errorf("encode image response data: %w", err)
-	}
-	envelope["data"] = updatedData
-	updatedBody, err := json.Marshal(envelope)
-	if err != nil {
-		return nil, 0, fmt.Errorf("encode image response: %w", err)
-	}
-	return updatedBody, converted, nil
-}
-
-func downloadImage(ctx context.Context, client *http.Client, rawURL string) ([]byte, error) {
-	parsed, err := url.Parse(rawURL)
-	if err != nil || parsed.Host == "" || (parsed.Scheme != "http" && parsed.Scheme != "https") {
-		return nil, errors.New("upstream returned an invalid image URL")
-	}
-
-	request, err := http.NewRequestWithContext(ctx, http.MethodGet, parsed.String(), nil)
-	if err != nil {
-		return nil, errors.New("create image download request")
-	}
-	request.Header.Set("Accept", "image/*")
-	request.Header.Set("User-Agent", "New-API-Image-Response-Adapter/1.0")
-
-	response, err := client.Do(request)
-	if err != nil {
-		return nil, errors.New("download upstream image")
-	}
-	defer response.Body.Close()
-	if response.StatusCode < http.StatusOK || response.StatusCode >= http.StatusMultipleChoices {
-		return nil, fmt.Errorf("image download returned HTTP %d", response.StatusCode)
-	}
-
-	imageBytes, err := readLimited(response.Body, maxDownloadedImageSize)
-	if err != nil {
-		return nil, fmt.Errorf("read upstream image: %w", err)
-	}
-	if len(imageBytes) == 0 {
-		return nil, errors.New("upstream image was empty")
-	}
-	detectedType := http.DetectContentType(imageBytes[:min(len(imageBytes), 512)])
-	declaredType := strings.ToLower(response.Header.Get("Content-Type"))
-	if !strings.HasPrefix(detectedType, "image/") && !strings.HasPrefix(declaredType, "image/") {
-		return nil, errors.New("downloaded URL did not return an image")
-	}
-	return imageBytes, nil
-}
-
-func newPublicImageClient() *http.Client {
-	dialer := &net.Dialer{Timeout: 15 * time.Second, KeepAlive: 30 * time.Second}
-	transport := http.DefaultTransport.(*http.Transport).Clone()
-	transport.Proxy = nil
-	transport.DialContext = func(ctx context.Context, network, address string) (net.Conn, error) {
-		host, port, err := net.SplitHostPort(address)
-		if err != nil {
-			return nil, errors.New("invalid image host")
-		}
-		addresses, err := net.DefaultResolver.LookupIPAddr(ctx, host)
-		if err != nil {
-			return nil, errors.New("resolve image host")
-		}
-		for _, address := range addresses {
-			if isPublicIP(address.IP) {
-				return dialer.DialContext(ctx, network, net.JoinHostPort(address.IP.String(), port))
-			}
-		}
-		return nil, errors.New("image URL resolved only to non-public addresses")
-	}
-	return &http.Client{
-		Transport: transport,
-		Timeout:   imageDownloadTimeout,
-		CheckRedirect: func(request *http.Request, via []*http.Request) error {
-			if len(via) >= 5 {
-				return errors.New("too many image URL redirects")
-			}
-			return nil
-		},
-	}
-}
-
-func isPublicIP(ip net.IP) bool {
-	return ip != nil &&
-		!ip.IsLoopback() &&
-		!ip.IsPrivate() &&
-		!ip.IsLinkLocalUnicast() &&
-		!ip.IsLinkLocalMulticast() &&
-		!ip.IsUnspecified() &&
-		!ip.IsMulticast()
-}
-
-func isImageEndpoint(path string) bool {
-	return path == "/v1/images/generations" || path == "/v1/images/edits"
-}
-
-func imageResponseModeForRequest(request *http.Request, fallback imageResponseMode) imageResponseMode {
-	if request == nil {
-		return fallback
-	}
-	if mode, err := parseImageResponseMode(request.Header.Get(responseFormatHeader)); err == nil && mode != "" {
-		return mode
-	}
-	if request.URL.Path != "/v1/images/generations" || request.Body == nil {
-		return fallback
-	}
-
-	prefix, err := io.ReadAll(io.LimitReader(request.Body, maxModeRequestBody+1))
-	request.Body = io.NopCloser(io.MultiReader(bytes.NewReader(prefix), request.Body))
-	if err != nil || len(prefix) > maxModeRequestBody {
-		return fallback
-	}
-	request.Body = io.NopCloser(bytes.NewReader(prefix))
-
-	var payload struct {
-		ResponseFormat string `json:"response_format"`
-	}
-	if err := json.Unmarshal(prefix, &payload); err != nil {
-		return fallback
-	}
-	if mode, err := parseImageResponseMode(payload.ResponseFormat); err == nil && mode != "" {
-		return mode
-	}
-	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
-	}
-	return imageResponseModeBase64
-}
-
-func parseImageResponseMode(raw string) (imageResponseMode, error) {
-	switch strings.ToLower(strings.TrimSpace(raw)) {
-	case "":
-		return "", nil
-	case "b64_json", "base64":
-		return imageResponseModeBase64, nil
-	case "url", "passthrough":
-		return imageResponseModeURL, nil
-	default:
-		return "", fmt.Errorf("invalid image response mode %q: use b64_json or url", raw)
-	}
-}
-
-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
-	}
-	var value string
-	if err := json.Unmarshal(raw, &value); err != nil || strings.TrimSpace(value) == "" {
-		return "", false
-	}
-	return value, true
-}
-
-func nonEmptyJSONString(raw json.RawMessage) bool {
-	_, ok := decodeNonEmptyString(raw)
-	return ok
-}
-
-func readLimited(reader io.Reader, limit int64) ([]byte, error) {
-	limited := io.LimitReader(reader, limit+1)
-	data, err := io.ReadAll(limited)
-	if err != nil {
-		return nil, err
-	}
-	if int64(len(data)) > limit {
-		return nil, fmt.Errorf("payload exceeds %d bytes", limit)
-	}
-	return data, nil
-}
-
-func resetResponseBody(response *http.Response, body []byte) {
-	response.Body = io.NopCloser(bytes.NewReader(body))
-	response.ContentLength = int64(len(body))
-	response.Header.Set("Content-Length", strconv.Itoa(len(body)))
-}
-
-func envOrDefault(key, fallback string) string {
-	if value := strings.TrimSpace(os.Getenv(key)); value != "" {
-		return value
-	}
-	return fallback
-}
-
-func envInt(key string, fallback, minimum, maximum int) (int, error) {
-	raw := strings.TrimSpace(os.Getenv(key))
-	if raw == "" {
-		return fallback, nil
-	}
-	value, err := strconv.Atoi(raw)
-	if err != nil || value < minimum || value > maximum {
-		return 0, fmt.Errorf("%s must be an integer from %d to %d", key, minimum, maximum)
-	}
-	return value, nil
-}
-
-func replaceEnv(env []string, key, value string) []string {
-	prefix := key + "="
-	result := make([]string, 0, len(env)+1)
-	for _, entry := range env {
-		if !strings.HasPrefix(entry, prefix) {
-			result = append(result, entry)
-		}
-	}
-	return append(result, prefix+value)
-}
-
-func shutdownServer(server *http.Server) {
-	ctx, cancel := context.WithTimeout(context.Background(), shutdownTimeout)
-	defer cancel()
-	if err := server.Shutdown(ctx); err != nil {
-		log.Printf("adapter shutdown: %v", err)
-	}
-}
-
-func stopChild(child *exec.Cmd, done <-chan error, sig os.Signal) {
-	if child.Process == nil {
-		return
-	}
-	_ = child.Process.Signal(sig)
-	select {
-	case <-done:
-		return
-	case <-time.After(shutdownTimeout):
-		_ = child.Process.Kill()
-		select {
-		case <-done:
-		case <-time.After(time.Second):
-		}
-	}
-}

adapter/main_test.go

@@ -1,444 +0,0 @@
-package main
-
-import (
-	"context"
-	"encoding/base64"
-	"encoding/json"
-	"fmt"
-	"io"
-	"net"
-	"net/http"
-	"net/http/httptest"
-	"net/url"
-	"strings"
-	"sync"
-	"sync/atomic"
-	"testing"
-	"time"
-)
-
-func TestConvertImageURLs(t *testing.T) {
-	input := []byte(`{"created":123,"data":[{"url":"https://cdn.example/image.png","revised_prompt":"final"}],"usage":{"total_tokens":9}}`)
-	fetches := 0
-	output, count, err := convertImageURLs(context.Background(), input, func(_ context.Context, rawURL string) ([]byte, error) {
-		fetches++
-		if rawURL != "https://cdn.example/image.png" {
-			t.Fatalf("unexpected URL: %s", rawURL)
-		}
-		return []byte("image-bytes"), nil
-	})
-	if err != nil {
-		t.Fatal(err)
-	}
-	if count != 1 || fetches != 1 {
-		t.Fatalf("count=%d fetches=%d", count, fetches)
-	}
-
-	var response struct {
-		Created int64 `json:"created"`
-		Data    []struct {
-			URL           string `json:"url"`
-			B64JSON       string `json:"b64_json"`
-			RevisedPrompt string `json:"revised_prompt"`
-		} `json:"data"`
-		Usage map[string]int `json:"usage"`
-	}
-	if err := json.Unmarshal(output, &response); err != nil {
-		t.Fatal(err)
-	}
-	if response.Created != 123 || response.Usage["total_tokens"] != 9 {
-		t.Fatalf("top-level fields were not preserved: %+v", response)
-	}
-	if response.Data[0].URL != "" {
-		t.Fatalf("URL should be removed: %q", response.Data[0].URL)
-	}
-	want := base64.StdEncoding.EncodeToString([]byte("image-bytes"))
-	if response.Data[0].B64JSON != want || response.Data[0].RevisedPrompt != "final" {
-		t.Fatalf("unexpected converted item: %+v", response.Data[0])
-	}
-}
-
-func TestConvertImageURLsLeavesBase64ResponseUnchanged(t *testing.T) {
-	input := []byte(`{"data":[{"b64_json":"aW1hZ2U="}]}`)
-	output, count, err := convertImageURLs(context.Background(), input, func(context.Context, string) ([]byte, error) {
-		t.Fatal("downloader should not be called")
-		return nil, nil
-	})
-	if err != nil {
-		t.Fatal(err)
-	}
-	if count != 0 || string(output) != string(input) {
-		t.Fatalf("response changed: count=%d output=%s", count, output)
-	}
-}
-
-func TestConvertImageURLsLeavesOtherJSONUnchanged(t *testing.T) {
-	input := []byte(`{"error":{"message":"upstream failure"}}`)
-	output, count, err := convertImageURLs(context.Background(), input, func(context.Context, string) ([]byte, error) {
-		t.Fatal("downloader should not be called")
-		return nil, nil
-	})
-	if err != nil {
-		t.Fatal(err)
-	}
-	if count != 0 || string(output) != string(input) {
-		t.Fatalf("response changed: count=%d output=%s", count, output)
-	}
-}
-
-func TestImageEndpointScope(t *testing.T) {
-	for _, path := range []string{"/v1/images/generations", "/v1/images/edits"} {
-		if !isImageEndpoint(path) {
-			t.Fatalf("expected image endpoint: %s", path)
-		}
-	}
-	for _, path := range []string{"/v1/responses", "/v1/chat/completions", "/console"} {
-		if isImageEndpoint(path) {
-			t.Fatalf("unexpected image endpoint: %s", path)
-		}
-	}
-}
-
-func TestImageResponseModeForRequest(t *testing.T) {
-	tests := []struct {
-		name     string
-		body     string
-		header   string
-		fallback imageResponseMode
-		want     imageResponseMode
-	}{
-		{name: "default base64", body: `{"model":"gpt-image-2"}`, fallback: imageResponseModeBase64, want: imageResponseModeBase64},
-		{name: "body URL", body: `{"model":"gpt-image-2","response_format":"url"}`, fallback: imageResponseModeBase64, want: imageResponseModeURL},
-		{name: "body base64", body: `{"response_format":"b64_json"}`, fallback: imageResponseModeURL, want: imageResponseModeBase64},
-		{name: "header wins", body: `{"response_format":"b64_json"}`, header: "url", fallback: imageResponseModeBase64, want: imageResponseModeURL},
-	}
-	for _, test := range tests {
-		t.Run(test.name, func(t *testing.T) {
-			request := httptest.NewRequest(http.MethodPost, "/v1/images/generations", strings.NewReader(test.body))
-			if test.header != "" {
-				request.Header.Set(responseFormatHeader, test.header)
-			}
-			got := imageResponseModeForRequest(request, test.fallback)
-			if got != test.want {
-				t.Fatalf("mode=%s want=%s", got, test.want)
-			}
-			body, err := io.ReadAll(request.Body)
-			if err != nil || string(body) != test.body {
-				t.Fatalf("request body was not preserved: body=%q err=%v", body, err)
-			}
-		})
-	}
-}
-
-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)
-	request = request.WithContext(context.WithValue(request.Context(), responseModeContextKey{}, imageResponseModeURL))
-	response := &http.Response{
-		StatusCode:    http.StatusOK,
-		Header:        make(http.Header),
-		Body:          io.NopCloser(strings.NewReader(body)),
-		ContentLength: int64(len(body)),
-		Request:       request,
-	}
-	if err := adaptImageResponse(response, func(context.Context, string) ([]byte, error) {
-		t.Fatal("downloader should not be called")
-		return nil, nil
-	}); err != nil {
-		t.Fatal(err)
-	}
-	got, err := io.ReadAll(response.Body)
-	if err != nil || string(got) != body {
-		t.Fatalf("URL response changed: body=%q err=%v", got, err)
-	}
-}
-
-func TestProxyConvertsDefaultImageResponse(t *testing.T) {
-	imageBytes := []byte("\x89PNG\r\n\x1a\nimage-data")
-	imageServer := httptest.NewServer(http.HandlerFunc(func(writer http.ResponseWriter, _ *http.Request) {
-		writer.Header().Set("Content-Type", "image/png")
-		_, _ = writer.Write(imageBytes)
-	}))
-	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, defaultAutoImageSize))
-	defer proxy.Close()
-
-	request, err := http.NewRequest(http.MethodPost, proxy.URL+"/v1/images/generations", strings.NewReader(`{"model":"gpt-image-2"}`))
-	if err != nil {
-		t.Fatal(err)
-	}
-	request.Header.Set("Content-Type", "application/json")
-	request.Header.Set(responseFormatHeader, "b64_json")
-	response, err := proxy.Client().Do(request)
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer response.Body.Close()
-
-	var payload struct {
-		Data []struct {
-			URL     string `json:"url"`
-			B64JSON string `json:"b64_json"`
-		} `json:"data"`
-	}
-	if err := json.NewDecoder(response.Body).Decode(&payload); err != nil {
-		t.Fatal(err)
-	}
-	if response.StatusCode != http.StatusOK {
-		t.Fatalf("status=%d", response.StatusCode)
-	}
-	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)
-	}
-}
-
-func TestProxyHonorsURLResponseFormat(t *testing.T) {
-	var downloads atomic.Int32
-	imageServer := httptest.NewServer(http.HandlerFunc(func(writer http.ResponseWriter, _ *http.Request) {
-		downloads.Add(1)
-		writer.Header().Set("Content-Type", "image/png")
-		_, _ = writer.Write([]byte("\x89PNG\r\n\x1a\nimage-data"))
-	}))
-	defer imageServer.Close()
-
-	backend := httptest.NewServer(http.HandlerFunc(func(writer http.ResponseWriter, _ *http.Request) {
-		writer.Header().Set("Content-Type", "application/json")
-		_, _ = fmt.Fprintf(writer, `{"data":[{"url":%q}]}`, imageServer.URL+"/image.png")
-	}))
-	defer backend.Close()
-
-	proxy := httptest.NewServer(newProxy(mustParseURL(t, backend.URL), imageServer.Client(), imageResponseModeBase64, 2, defaultAutoImageSize))
-	defer proxy.Close()
-
-	response, err := proxy.Client().Post(
-		proxy.URL+"/v1/images/generations",
-		"application/json",
-		strings.NewReader(`{"model":"gpt-image-2","response_format":"url"}`),
-	)
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer response.Body.Close()
-	body, err := io.ReadAll(response.Body)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if !strings.Contains(string(body), imageServer.URL) {
-		t.Fatalf("URL response was not preserved: %s", body)
-	}
-	if downloads.Load() != 0 {
-		t.Fatalf("URL mode downloaded %d image(s)", downloads.Load())
-	}
-}
-
-func TestProxyLeavesNonImageResponseUnchanged(t *testing.T) {
-	const body = `{"id":"resp_123","output":[{"type":"message"}]}`
-	backend := httptest.NewServer(http.HandlerFunc(func(writer http.ResponseWriter, request *http.Request) {
-		if request.URL.Path != "/v1/responses" {
-			t.Fatalf("unexpected path: %s", request.URL.Path)
-		}
-		writer.Header().Set("Content-Type", "application/json")
-		writer.Header().Set("X-Upstream", "preserved")
-		_, _ = io.WriteString(writer, body)
-	}))
-	defer backend.Close()
-
-	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 {
-		t.Fatal(err)
-	}
-	defer response.Body.Close()
-	got, err := io.ReadAll(response.Body)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if string(got) != body || response.Header.Get("X-Upstream") != "preserved" {
-		t.Fatalf("non-image response changed: body=%s headers=%v", got, response.Header)
-	}
-}
-
-func TestProxyLimitsConcurrentImageDownloads(t *testing.T) {
-	const (
-		requestCount  = 6
-		concurrency   = 2
-		assertionWait = 200 * time.Millisecond
-	)
-	entered := make(chan struct{}, requestCount)
-	release := make(chan struct{})
-	var releaseOnce sync.Once
-	releaseDownloads := func() { releaseOnce.Do(func() { close(release) }) }
-	defer releaseDownloads()
-	var active atomic.Int32
-	var maximum atomic.Int32
-	imageServer := httptest.NewServer(http.HandlerFunc(func(writer http.ResponseWriter, _ *http.Request) {
-		current := active.Add(1)
-		defer active.Add(-1)
-		for current > maximum.Load() && !maximum.CompareAndSwap(maximum.Load(), current) {
-		}
-		entered <- struct{}{}
-		<-release
-		writer.Header().Set("Content-Type", "image/png")
-		_, _ = writer.Write([]byte("\x89PNG\r\n\x1a\nimage-data"))
-	}))
-	defer imageServer.Close()
-
-	backend := httptest.NewServer(http.HandlerFunc(func(writer http.ResponseWriter, _ *http.Request) {
-		writer.Header().Set("Content-Type", "application/json")
-		_, _ = 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, defaultAutoImageSize))
-	defer proxy.Close()
-
-	errors := make(chan error, requestCount)
-	var requests sync.WaitGroup
-	for range requestCount {
-		requests.Add(1)
-		go func() {
-			defer requests.Done()
-			response, err := proxy.Client().Post(proxy.URL+"/v1/images/generations", "application/json", strings.NewReader(`{"model":"gpt-image-2"}`))
-			if err != nil {
-				errors <- err
-				return
-			}
-			_, readErr := io.Copy(io.Discard, response.Body)
-			closeErr := response.Body.Close()
-			if readErr != nil {
-				errors <- readErr
-			} else if closeErr != nil {
-				errors <- closeErr
-			}
-		}()
-	}
-
-	for range concurrency {
-		select {
-		case <-entered:
-		case <-time.After(2 * time.Second):
-			t.Fatal("concurrent downloads did not start")
-		}
-	}
-	select {
-	case <-entered:
-		t.Fatal("download concurrency limit was exceeded")
-	case <-time.After(assertionWait):
-	}
-	releaseDownloads()
-
-	done := make(chan struct{})
-	go func() {
-		requests.Wait()
-		close(done)
-	}()
-	select {
-	case <-done:
-	case <-time.After(5 * time.Second):
-		t.Fatal("proxy requests did not finish")
-	}
-	close(errors)
-	for err := range errors {
-		t.Error(err)
-	}
-	if maximum.Load() > concurrency {
-		t.Fatalf("maximum concurrent downloads=%d want<=%d", maximum.Load(), concurrency)
-	}
-}
-
-func mustParseURL(t *testing.T, rawURL string) *url.URL {
-	t.Helper()
-	parsed, err := url.Parse(rawURL)
-	if err != nil {
-		t.Fatal(err)
-	}
-	return parsed
-}
-
-func TestPublicIPGuard(t *testing.T) {
-	for _, raw := range []string{"127.0.0.1", "10.0.0.1", "192.168.1.2", "169.254.1.1", "::1"} {
-		if isPublicIP(net.ParseIP(raw)) {
-			t.Fatalf("private address accepted: %s", raw)
-		}
-	}
-	for _, raw := range []string{"1.1.1.1", "8.8.8.8", "2606:4700:4700::1111"} {
-		if !isPublicIP(net.ParseIP(raw)) {
-			t.Fatalf("public address rejected: %s", raw)
-		}
-	}
-}