支持远程url吗

backend/internal/provider/adobe/client.go

@@ -174,7 +174,7 @@ func (c *Client) uploadImageOnce(ctx context.Context, token string, content []by
 	return body, nil, true
 }
 
-func (c *Client) GenerateImage(ctx context.Context, token, modelID, prompt, aspectRatio, resolution string, blobIDs []string) ([]byte, map[string]any, error) {
+func (c *Client) GenerateImage(ctx context.Context, token, modelID, prompt, aspectRatio, resolution string, blobIDs []string, downloadResult bool) ([]byte, map[string]any, error) {
 	// Only the generate submit goes through the proxy; polling + download run on
 	// the local IP.
 	submitSess, err := c.newTLSClient()
@@ -201,7 +201,7 @@ func (c *Client) GenerateImage(ctx context.Context, token, modelID, prompt, aspe
 	for _, payload := range candidates {
 		respBody, pollURL, err := c.submitImage(ctx, submitSess, token, prompt, endpoint, payload)
 		if err == nil {
-			meta, data, pollErr := c.pollImage(ctx, pollSess, token, pollURL)
+			meta, data, pollErr := c.pollImage(ctx, pollSess, token, pollURL, downloadResult)
 			if pollErr != nil {
 				return nil, nil, pollErr
 			}
@@ -531,7 +531,7 @@ func (c *Client) submitImage(ctx context.Context, sess *tlsSession, token, promp
 	return respBody, "", errors.New("submit ok but no poll url")
 }
 
-func (c *Client) pollImage(ctx context.Context, sess *tlsSession, token, pollURL string) (map[string]any, []byte, error) {
+func (c *Client) pollImage(ctx context.Context, sess *tlsSession, token, pollURL string, downloadResult bool) (map[string]any, []byte, error) {
 	for {
 		if err := ctx.Err(); err != nil {
 			return nil, nil, fmt.Errorf("adobe generation timed out: %w", err)
@@ -587,6 +587,11 @@ func (c *Client) pollImage(ctx context.Context, sess *tlsSession, token, pollURL
 			if first, ok := outputs[0].(map[string]any); ok {
 				if image, ok := first["image"].(map[string]any); ok {
 					if url := strings.TrimSpace(stringValue(image["presignedUrl"])); url != "" {
+						// Expose the presigned URL for callers that want it directly.
+						payload["image_url"] = url
+						if !downloadResult {
+							return payload, nil, nil
+						}
 						data, err := c.download(ctx, sess, url)
 						if err != nil {
 							return nil, nil, err

backend/internal/provider/chatgpt/client.go

@@ -68,7 +68,7 @@ func (c *Client) SetProxy(proxy string) {
 	c.proxy = strings.TrimSpace(proxy)
 }
 
-func (c *Client) GenerateImage(ctx context.Context, accessToken, prompt, model, aspectRatio, resolution string, refs [][]byte) ([]byte, map[string]any, error) {
+func (c *Client) GenerateImage(ctx context.Context, accessToken, prompt, model, aspectRatio, resolution string, refs [][]byte, downloadResult bool) ([]byte, map[string]any, error) {
 	// Everything except the generation submit egresses on the local IP. Only
 	// startImageGeneration (the /backend-api/f/conversation POST) goes through
 	// the proxy; the bootstrap / chat-requirements / reference upload / prepare
@@ -130,6 +130,17 @@ func (c *Client) GenerateImage(ctx context.Context, accessToken, prompt, model,
 	if len(urls) == 0 {
 		return nil, nil, errors.New("no image urls resolved")
 	}
+	meta := map[string]any{
+		"provider":        "chatgpt",
+		"model":           model,
+		"conversation_id": conversationID,
+		"image_url":       urls[0], // auth-gated (files.oaiusercontent.com) — needs the account token to fetch
+	}
+	// downloadResult=false: skip the (auth-gated) download and return just the URL;
+	// the caller proxies it via OpenAsset with the account token.
+	if !downloadResult {
+		return nil, meta, nil
+	}
 	images, err := c.downloadBytes(ctx, session, accessToken, urls)
 	if err != nil {
 		return nil, nil, err
@@ -137,11 +148,36 @@ func (c *Client) GenerateImage(ctx context.Context, accessToken, prompt, model,
 	if len(images) == 0 {
 		return nil, nil, errors.New("download produced no bytes")
 	}
-	return images[0], map[string]any{
-		"provider":        "chatgpt",
-		"model":           model,
-		"conversation_id": conversationID,
-	}, nil
+	return images[0], meta, nil
+}
+
+// OpenAsset streams an auth-gated ChatGPT image URL (files.oaiusercontent.com)
+// using the generating account's token — a plain GET 403s. Mirrors downloadBytes
+// but returns a live stream instead of buffering.
+func (c *Client) OpenAsset(ctx context.Context, accessToken, rawURL string) (io.ReadCloser, string, error) {
+	session, err := c.newDirectSession(accessToken)
+	if err != nil {
+		return nil, "", err
+	}
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, rawURL, nil)
+	if err != nil {
+		return nil, "", err
+	}
+	req.Header = c.baseHeaders(accessToken)
+	req.Header.Set("accept", "*/*")
+	resp, err := session.Do(req)
+	if err != nil {
+		return nil, "", fmt.Errorf("%w: %v", ErrTemporaryUpstream, err)
+	}
+	if resp.StatusCode != 200 {
+		resp.Body.Close()
+		return nil, "", fmt.Errorf("%w: chatgpt asset status %d", ErrTemporaryUpstream, resp.StatusCode)
+	}
+	ct := strings.TrimSpace(resp.Header.Get("Content-Type"))
+	if ct == "" {
+		ct = "image/png"
+	}
+	return resp.Body, ct, nil
 }
 
 func ExtractAccountInfo(token string) map[string]any {

backend/internal/provider/custom/client.go

@@ -8,7 +8,6 @@ package custom
 import (
 	"bytes"
 	"context"
-	"encoding/base64"
 	"encoding/json"
 	"errors"
 	"fmt"
@@ -61,10 +60,10 @@ func httpClient() *http.Client { return &http.Client{Timeout: 10 * time.Minute}
 // GenerateImage calls the upstream OpenAI image API. With reference images it
 // uses /v1/images/edits (multipart); otherwise /v1/images/generations. Returns
 // the raw image bytes (decoded from b64_json, or downloaded from url).
-func (c *Client) GenerateImage(ctx context.Context, baseURL, apiKey, model, prompt, size, quality string, refs [][]byte) ([]byte, error) {
+func (c *Client) GenerateImage(ctx context.Context, baseURL, apiKey, model, prompt, size, quality string, refs [][]byte, downloadResult bool) ([]byte, string, error) {
 	baseURL = strings.TrimRight(strings.TrimSpace(baseURL), "/")
 	if baseURL == "" || apiKey == "" {
-		return nil, ErrAuth
+		return nil, "", ErrAuth
 	}
 	var req *http.Request
 	var err error
@@ -73,24 +72,26 @@ func (c *Client) GenerateImage(ctx context.Context, baseURL, apiKey, model, prom
 		w := multipart.NewWriter(body)
 		_ = w.WriteField("model", model)
 		_ = w.WriteField("prompt", prompt)
+		// Ask the upstream for a URL (not base64) so we can pass it through directly.
+		_ = w.WriteField("response_format", "url")
 		if size != "" {
 			_ = w.WriteField("size", size)
 		}
 		for i, r := range refs {
 			fw, e := w.CreateFormFile("image[]", fmt.Sprintf("ref_%d.png", i+1))
 			if e != nil {
-				return nil, e
+				return nil, "", e
 			}
 			_, _ = fw.Write(r)
 		}
 		_ = w.Close()
 		req, err = http.NewRequest(http.MethodPost, baseURL+"/v1/images/edits", body)
 		if err != nil {
-			return nil, err
+			return nil, "", err
 		}
 		req.Header.Set("Content-Type", w.FormDataContentType())
 	} else {
-		payload := map[string]any{"model": model, "prompt": prompt, "n": 1}
+		payload := map[string]any{"model": model, "prompt": prompt, "n": 1, "response_format": "url"}
 		if size != "" {
 			payload["size"] = size
 		}
@@ -100,7 +101,7 @@ func (c *Client) GenerateImage(ctx context.Context, baseURL, apiKey, model, prom
 		raw, _ := json.Marshal(payload)
 		req, err = http.NewRequest(http.MethodPost, baseURL+"/v1/images/generations", bytes.NewReader(raw))
 		if err != nil {
-			return nil, err
+			return nil, "", err
 		}
 		req.Header.Set("Content-Type", "application/json")
 	}
@@ -109,14 +110,14 @@ func (c *Client) GenerateImage(ctx context.Context, baseURL, apiKey, model, prom
 
 	resp, err := httpClient().Do(req)
 	if err != nil {
-		return nil, fmt.Errorf("%w: %s", ErrTemporaryUpstream, sanitizeErr(err))
+		return nil, "", fmt.Errorf("%w: %s", ErrTemporaryUpstream, sanitizeErr(err))
 	}
 	defer resp.Body.Close()
 	body, _ := io.ReadAll(resp.Body)
 	if e := mapStatus(resp.StatusCode, body); e != nil {
-		return nil, e
+		return nil, "", e
 	}
-	return imageBytesFromResponse(ctx, body)
+	return imageFromResponse(ctx, body, downloadResult)
 }
 
 // GenerateVideo drives the upstream Sora-style async video API:
@@ -239,34 +240,34 @@ func (c *Client) download(ctx context.Context, url, apiKey string) ([]byte, erro
 
 // imageBytesFromResponse extracts image bytes from an OpenAI images response:
 // data[0].b64_json (preferred) or data[0].url (downloaded).
-func imageBytesFromResponse(ctx context.Context, body []byte) ([]byte, error) {
+// imageFromResponse parses an OpenAI image response and returns the upstream URL.
+// We always request response_format=url, so the response must carry a URL — a
+// base64-only response is treated as an error (no base64 pass-through). With
+// downloadResult=false the URL is returned directly (no download).
+func imageFromResponse(ctx context.Context, body []byte, downloadResult bool) ([]byte, string, error) {
 	var out struct {
 		Data []struct {
-			B64JSON string `json:"b64_json"`
-			URL     string `json:"url"`
+			URL string `json:"url"`
 		} `json:"data"`
 	}
 	if err := json.Unmarshal(body, &out); err != nil || len(out.Data) == 0 {
-		return nil, fmt.Errorf("%w: bad image response: %s", ErrTemporaryUpstream, clip(body, 160))
+		return nil, "", fmt.Errorf("%w: bad image response: %s", ErrTemporaryUpstream, clip(body, 160))
 	}
-	d := out.Data[0]
-	if d.B64JSON != "" {
-		raw, err := base64.StdEncoding.DecodeString(strings.TrimSpace(d.B64JSON))
-		if err != nil {
-			return nil, fmt.Errorf("%w: bad b64: %v", ErrTemporaryUpstream, err)
-		}
-		return raw, nil
+	url := strings.TrimSpace(out.Data[0].URL)
+	if url == "" {
+		return nil, "", fmt.Errorf("%w: image response had no url (upstream ignored response_format=url)", ErrTemporaryUpstream)
 	}
-	if d.URL != "" {
-		req, _ := http.NewRequestWithContext(ctx, http.MethodGet, d.URL, nil)
-		resp, err := httpClient().Do(req)
-		if err != nil {
-			return nil, fmt.Errorf("%w: %s", ErrTemporaryUpstream, sanitizeErr(err))
-		}
-		defer resp.Body.Close()
-		return io.ReadAll(resp.Body)
+	if !downloadResult {
+		return nil, url, nil
 	}
-	return nil, fmt.Errorf("%w: image response had no b64/url", ErrTemporaryUpstream)
+	req, _ := http.NewRequestWithContext(ctx, http.MethodGet, url, nil)
+	resp, err := httpClient().Do(req)
+	if err != nil {
+		return nil, "", fmt.Errorf("%w: %s", ErrTemporaryUpstream, sanitizeErr(err))
+	}
+	defer resp.Body.Close()
+	raw, err := io.ReadAll(resp.Body)
+	return raw, url, err
 }
 
 func mapStatus(status int, body []byte) error {

backend/internal/provider/imagine/image.go

@@ -18,7 +18,7 @@ import (
 // the org objects feed until the batch finishes, then download the produced
 // image. styleID picks the model (41001 = 1.5 / 2K, 41004 = 1.5pro / 4K).
 // HTTP 402 → ErrQuotaExhausted. These models are pure text2img (no refs).
-func (c *Client) GenerateImage(ctx context.Context, cred string, styleID int, resolution, aspectRatio, prompt string) ([]byte, map[string]any, error) {
+func (c *Client) GenerateImage(ctx context.Context, cred string, styleID int, resolution, aspectRatio, prompt string, downloadResult bool) ([]byte, map[string]any, error) {
 	cr, ok := parseCred(cred)
 	if !ok {
 		return nil, nil, ErrAuth
@@ -85,11 +85,15 @@ func (c *Client) GenerateImage(ctx context.Context, cred string, styleID int, re
 	if err != nil {
 		return nil, nil, err
 	}
+	meta := map[string]any{"batch_id": batchID, "image_url": imageURL, "org_id": userID}
+	if !downloadResult {
+		return nil, meta, nil
+	}
 	data, err := c.download(ctx, imageURL)
 	if err != nil {
 		return nil, nil, err
 	}
-	return data, map[string]any{"batch_id": batchID, "image_url": imageURL, "org_id": userID}, nil
+	return data, meta, nil
 }
 
 // pollImage polls the org objects feed until the entry for our batch finishes,

backend/internal/provider/krea/image.go

@@ -89,7 +89,7 @@ func (c *Client) uploadImage(ctx context.Context, cookie string, img []byte) (st
 // GenerateImage runs the full Krea image pipeline: ensure a project, (for i2i)
 // upload reference images, submit the job, poll until done, then resolve and
 // download the produced image. 402 INSUFFICIENT_BALANCE → ErrQuotaExhausted.
-func (c *Client) GenerateImage(ctx context.Context, cookie, prompt string, width, height int, refImages [][]byte) ([]byte, map[string]any, error) {
+func (c *Client) GenerateImage(ctx context.Context, cookie, prompt string, width, height int, refImages [][]byte, downloadResult bool) ([]byte, map[string]any, error) {
 	// Ensure the daily free balance is granted (load /app) before generating, so a
 	// not-yet-activated account doesn't 402 INSUFFICIENT_BALANCE. Lock-guarded and
 	// once-per-daily-reset — concurrent gens wait for the first activation, already
@@ -169,11 +169,15 @@ func (c *Client) GenerateImage(ctx context.Context, cookie, prompt string, width
 	if err != nil {
 		return nil, nil, err
 	}
+	meta := map[string]any{"job_id": jobID, "image_url": imageURL, "project": projectID}
+	if !downloadResult {
+		return nil, meta, nil
+	}
 	data, err := c.download(ctx, imageURL)
 	if err != nil {
 		return nil, nil, err
 	}
-	return data, map[string]any{"job_id": jobID, "image_url": imageURL, "project": projectID}, nil
+	return data, meta, nil
 }
 
 // pollImage polls job-status until the job leaves the queue, then matches the

backend/internal/provider/leonardo/image.go

@@ -136,7 +136,7 @@ func (c *Client) uploadInitImage(ctx context.Context, accessToken string, img []
 // mint a JWT, (for image-to-image) upload each reference image, submit the
 // Generate mutation, poll until COMPLETE, then download the first produced image.
 // Returns the image bytes, an info map, and a classified error.
-func (c *Client) GenerateImage(ctx context.Context, cookie, model, prompt string, width, height int, styleIDs []string, refImages [][]byte) ([]byte, map[string]any, error) {
+func (c *Client) GenerateImage(ctx context.Context, cookie, model, prompt string, width, height int, styleIDs []string, refImages [][]byte, downloadResult bool) ([]byte, map[string]any, error) {
 	sess, err := c.GetSession(ctx, cookie)
 	if err != nil {
 		return nil, nil, err
@@ -226,16 +226,19 @@ func (c *Client) GenerateImage(ctx context.Context, cookie, model, prompt string
 		return nil, nil, err
 	}
 
-	// 3. download bytes
-	data, err := c.downloadImage(ctx, imageURL)
-	if err != nil {
-		return nil, nil, err
-	}
 	info := map[string]any{
 		"generation_id": genID,
 		"image_url":     imageURL,
 		"user_id":       sess.UserID,
 	}
+	if !downloadResult {
+		return nil, info, nil
+	}
+	// 3. download bytes
+	data, err := c.downloadImage(ctx, imageURL)
+	if err != nil {
+		return nil, nil, err
+	}
 	return data, info, nil
 }
 

backend/internal/provider/runway/image.go

@@ -20,7 +20,7 @@ import (
 // anything else → workflow_gemini_image / gemini-3-pro-image-preview. imageSize
 // is the "1K"/"2K"/"4K" tier. teamID is the workspace id; if empty it's derived
 // from the token. refs may be empty (pure text-to-image).
-func (c *Client) GenerateImage(ctx context.Context, token, teamID, modelID, prompt, aspectRatio, imageSize string, refs [][]byte) ([]byte, map[string]any, error) {
+func (c *Client) GenerateImage(ctx context.Context, token, teamID, modelID, prompt, aspectRatio, imageSize string, refs [][]byte, downloadResult bool) ([]byte, map[string]any, error) {
 	token = strings.TrimSpace(strings.TrimPrefix(token, "Bearer "))
 	if token == "" {
 		return nil, nil, ErrAuth
@@ -86,16 +86,21 @@ func (c *Client) GenerateImage(ctx context.Context, token, teamID, modelID, prom
 	if err != nil {
 		return nil, nil, err
 	}
-	data, err := c.download(ctx, directClient, artifactURL)
-	if err != nil {
-		return nil, nil, err
-	}
 	meta := map[string]any{
 		"provider":  "runway",
 		"task_id":   taskID,
 		"team_id":   teamID,
 		"image_url": artifactURL,
 	}
+	// downloadResult=false (API-key url-only mode): return the upstream artifact
+	// URL without downloading the PNG.
+	if !downloadResult {
+		return nil, meta, nil
+	}
+	data, err := c.download(ctx, directClient, artifactURL)
+	if err != nil {
+		return nil, nil, err
+	}
 	return data, meta, nil
 }