gcli2api / internal /server /images.go
a3216's picture
feat: 同步上游 320f5d4;扩展模型(多免费渠道/自定义映射/访问密钥/模型白名单)
e48a2d8
Raw History Blame Contribute Delete
19.5 kB
// images.go 图像端点:POST /v1/images/generations(文生图)与 /v1/images/edits(图生图)。
//
// 上游图像模型不进**对话**列表(目录按 tag text-to-image 剔除,选它发对话会 11102),
// 所以模型名不走目录校验,按 realm 前缀路由到对应账号池:
//
// cn:hunyuan-image-alpha 国内版(实测 200 + 签名 COS URL)
// cn:hunyuan-image-alpha-edit 国内版图生图
// global:hy-image-3.5 国际版(2026-10-22 实测 200 + credit 0.27/张)
// global:gpt-image-2.5-sunburst 已下架(400 code=14401 route config not found)
//
// 裸名 → realm 的映射表在 upstream(imageRouteRealm),已下架模型表为 imageDeadModels;
// 两者都只写实测过的组合,未知模型照旧放行(不猜)。
//
// 请求体只把 model 换成裸名(前缀是网关路由协议,上游只认裸名),其余原样透传;
// multipart 请求(OpenAI SDK 的 images.edit 走这条)就地转成上游要的 JSON(图片转 data URL)。
// 回程把上游 data 原样写出——它已是 {created,data:[{url}],usage},不转存、不改写。
package server
import (
"context"
"encoding/base64"
"encoding/json"
"errors"
"fmt"
"io"
"log"
"mime/multipart"
"net/http"
"strconv"
"strings"
"time"
"github.com/misakano7545/workbuddy2api-panel/internal/logfmt"
"github.com/misakano7545/workbuddy2api-panel/internal/proxypool"
"github.com/misakano7545/workbuddy2api-panel/internal/reqlog"
"github.com/misakano7545/workbuddy2api-panel/internal/upstream"
"github.com/misakano7545/workbuddy2api-panel/internal/usage"
)
// defaultImageModel 请求未带 model 时的缺省图像模型(国内版;realm 由前缀决定)。
const defaultImageModel = "cn:hunyuan-image-alpha"
// firstAllowedGenerationImage 白名单兜底(issue #68 设计决策 4):从最近一次目录
// 解析留存的出图模型里,按 cn 优先、global 其次返回第一个「白名单内且未被黑名单
// 隐藏」的 image 模型 (realm, 裸名)。白名单未启用 / 无目录 / 无命中 → false,
// 调用方维持默认名走拒绝路径(不做隐式放行)。
func (h *Handler) firstAllowedGenerationImage() (string, string, bool) {
snap := h.loadLive()
if !snap.AllowlistEnabled || h.cfg.Upstream == nil {
return "", "", false
}
realms := []string{"cn"}
if h.cfg.GlobalEnabled {
realms = append(realms, "global")
}
for _, realm := range realms {
for _, mi := range h.cfg.Upstream.GenerationModels(realm) {
if mi.GenerationKind != "image" {
continue
}
if h.hiddenModel(realm, mi.ID) {
continue
}
if _, ok := snap.AllowedModels[realm+":"+mi.ID]; !ok {
continue
}
return realm, mi.ID, true
}
}
return "", "", false
}
// imageAttempts 失败换号上限(与 chat 路径同量级:图像按次人工触发,3 次足够绕开坏号)。
const imageAttempts = 3
// imagesGenerations / imagesEdits 共用实现;edit 决定上游路径与入参校验。
func (h *Handler) images(w http.ResponseWriter, r *http.Request, edit bool) {
start := time.Now()
raw, berr := h.readBody(w, r)
if berr != nil {
h.writeBodyError(w, berr, false)
return
}
req, err := imageRequest(r, raw, edit)
if err != nil {
writeOpenAIError(w, http.StatusBadRequest, "invalid_request", err.Error())
return
}
// 出图也有「上下文」(prompt,编辑还有原图):同一开关,同一处归档。
if h.loadLive().RecordContext {
if tr := requestTraceFrom(r); tr != nil {
tr.context = archiveContext(raw)
}
}
// 上游一次只出一张(2026-11-05 实测 n=2 仍只回 1 条),按规范明确拒绝而不是静默少给。
if n, ok := numberToInt(req["n"]); ok && n > 1 {
writeOpenAIError(w, http.StatusBadRequest, "invalid_request",
"n>1 暂不支持:上游一次只出一张,请逐次请求(每次一张)")
return
}
prompt, _ := req["prompt"].(string)
if strings.TrimSpace(prompt) == "" {
writeOpenAIError(w, http.StatusBadRequest, "invalid_request",
`prompt is required(例:{"model":"`+defaultImageModel+`","prompt":"一只猫"})`)
return
}
realm, bare, merr := h.imageModel(asString(req["model"]))
if merr != nil {
writeOpenAIError(w, http.StatusBadRequest, "model_unavailable", merr.Error())
return
}
req["model"] = bare
out, err := json.Marshal(req)
if err != nil {
writeOpenAIError(w, http.StatusInternalServerError, "internal_error", err.Error())
return
}
// 记账:与 chat 同一条管道(请求台账归档由 ServeHTTP 的 isChatEntry 接管,
// 这里补账号/模型/用量/扣费 → stdout 流水行 + 面板「请求记录」+ 用量与成本账本)。
st := &chatStat{start: start, model: bare, mode: imageMode(edit), toks: -1, budget: h.budget}
if tr := requestTraceFrom(r); tr != nil {
tr.stat = st
st.requestID = tr.id
st.clientIP, st.userAgent = tr.clientIP, tr.userAgent
}
defer st.done()
modelRate := ""
if h.cfg.Upstream != nil {
modelRate = h.cfg.Upstream.ModelRate(realm, bare)
}
tried := map[string]bool{}
var lastErr error
for attempt := 0; attempt < imageAttempts; attempt++ {
a := h.cfg.Pool.PickExcludingForRealm(tried, bare, realm)
if a == nil {
break
}
tried[a.UID] = true
st.uid, st.nick = a.UID, a.Nickname
st.attempts = attempt + 1
var data []byte
if edit {
data, err = h.cfg.Upstream.ImageEdits(a, json.RawMessage(out))
} else {
data, err = h.cfg.Upstream.ImageGenerations(a, json.RawMessage(out))
}
if err != nil {
lastErr = err
if proxypool.IsError(err) {
break
}
var ue *upstream.Error
if errors.As(err, &ue) {
// 与 chat 同一套失败处置(冷却/熔断/模型负缓存/12153 计数)。
h.applyErrorPolicy(a.UID, ue.Kind, ue.Msg, bare, ue)
// 请求级/模型级错误与账号无关:审核与参数是请求本身的属性,14401/11102 是
// 该模型在本域没有路由。换号必然同样失败——实测 14401 会打满全池账号,
// 白烧上游调用;客户端还会把 502 当瞬时故障反复重试。立即透传原文回 400。
if requestLevelFailFastKind(ue.Kind) {
status := ue.Status
if status < 400 {
status = http.StatusBadRequest
}
st.status, st.outcome = status, "http_error"
log.Printf("images model=%s realm=%s: 请求级错误 kind=%v,不再换号", bare, realm, ue.Kind)
writeOpenAIError(w, status, "upstream_error", ue.Msg)
return
}
}
log.Printf("images %s model=%s attempt=%d: %v", logfmt.Label(a.UID, a.Nickname), bare, attempt+1, err)
continue
}
lastErr = nil
recordImageUsage(h, st, realm, a.UID, bare, modelRate, data, req, start)
if asString(req["response_format"]) == "b64_json" {
data = b64JSONImages(r.Context(), data)
}
w.Header().Set("Content-Type", "application/json")
_, _ = w.Write(data)
return
}
status, code := http.StatusBadGateway, "upstream_error"
var ue *upstream.Error
switch {
case proxypool.IsError(lastErr):
status, code = http.StatusServiceUnavailable, "proxy_unavailable"
case len(tried) == 0: // 一个可用账号都没有:没有可重试的对象,明确说清楚
status, code = http.StatusServiceUnavailable, "no_account"
lastErr = fmt.Errorf("没有可用的 %s 账号(图像只在 %s 域出图)", realm, realm)
case errors.As(lastErr, &ue) && ue.Status >= 400:
status = ue.Status // 上游状态码(如 14401 的 400)比一律 502 更能说明问题
}
st.status = status
st.outcome = ""
log.Printf("images model=%s realm=%s: 全部尝试失败(%d 个账号):%v", bare, realm, len(tried), lastErr)
writeOpenAIError(w, status, code, lastErr.Error())
}
// imageModel 出图入口的模型口径:缺省 defaultImageModel,再按 models.allowed /
// models.hidden 双名单裁定,返回 (realm, 裸模型名)。错误文案与 chat 侧同口径,
// 避免枚举探测。
//
// models.allowed 白名单(issue #68):与 chat 入口同款拒绝,不打上游、不占选号。
// 未点名模型时先做白名单内兜底(设计决策 4):默认模型不在白名单时改选白名单内
// 第一个可用出图模型;白名单内无出图模型则维持默认名落入拒绝(不做隐式放行)。
// models.hidden 同一份黑名单也管出图入口:列表里已经隐藏的模型不该还能直接调
// (白名单兜底选出的模型也在此受检:白名单∩黑名单交集语义,隐藏的不例外)。
func (h *Handler) imageModel(model string) (string, string, error) {
named := strings.TrimSpace(model) != "" // 客户端是否显式点名了模型
if !named {
model = defaultImageModel
}
realm, bare := resolveModel(model)
if !h.allowedModel(realm, bare) {
if named {
return "", "", errors.New("model is not in the gateway allowlist, try another model")
}
fr, fb, ok := h.firstAllowedGenerationImage()
if !ok {
return "", "", errors.New("model is not in the gateway allowlist, try another model")
}
realm, bare = fr, fb
}
if h.hiddenModel(realm, bare) {
return "", "", errors.New("model is hidden by gateway configuration, try another model")
}
return realm, bare, nil
}
// imageGenerate 网关侧出一次图:选号 → 出图 → 记账,返回上游原始回执(图片链接在
// data[].url 里)。托管 image_generation 工具的执行器走这里(见 imagetool.go),
// 与 HTTP 入口共享模型口径、选号重试与记账口径。
//
// 流水行自成一行,带该 Responses 请求的 rid/IP/UA 以便对账;不碰 tr.stat(那是对话
// 本身的统计对象,归 chatCompletions)。客户端断连后不再起新的出图尝试;已经发出去的
// 那次不取消——上游多半照扣,取消只会让回执丢失、账本少记。
func (h *Handler) imageGenerate(ctx context.Context, req map[string]any) ([]byte, error) {
realm, bare, err := h.imageModel(asString(req["model"]))
if err != nil {
return nil, err
}
req["model"] = bare
out, err := json.Marshal(req)
if err != nil {
return nil, err
}
st := newChatStat(time.Now(), bare, false, h.budget)
if tr, _ := ctx.Value(requestTraceKey{}).(*requestTrace); tr != nil {
st.requestID = tr.id
st.clientIP, st.userAgent = tr.clientIP, tr.userAgent
}
defer st.done()
modelRate := ""
if h.cfg.Upstream != nil {
modelRate = h.cfg.Upstream.ModelRate(realm, bare)
}
tried := map[string]bool{}
var lastErr error
for attempt := 0; attempt < imageAttempts; attempt++ {
if err := ctx.Err(); err != nil {
lastErr = err
break
}
a := h.cfg.Pool.PickExcludingForRealm(tried, bare, realm)
if a == nil {
break
}
tried[a.UID] = true
st.uid, st.nick, st.attempts = a.UID, a.Nickname, attempt+1
data, ierr := h.cfg.Upstream.ImageGenerations(a, json.RawMessage(out))
if ierr != nil {
lastErr = ierr
if proxypool.IsError(ierr) {
break // 代理池不可用与账号无关,换号只会重复同样的失败(同 images)
}
var ue *upstream.Error
if errors.As(ierr, &ue) {
h.applyErrorPolicy(a.UID, ue.Kind, ue.Msg, bare, ue)
if requestLevelFailFastKind(ue.Kind) {
// 与账号无关的错误:换号必然同样失败
st.status, st.outcome = max(ue.Status, http.StatusBadRequest), "http_error"
return nil, ierr
}
}
log.Printf("images %s model=%s attempt=%d: %v", logfmt.Label(a.UID, a.Nickname), bare, attempt+1, ierr)
continue
}
recordImageUsage(h, st, realm, a.UID, bare, modelRate, data, req, st.start)
return data, nil
}
if lastErr == nil {
lastErr = fmt.Errorf("没有可用的 %s 账号", realm)
}
if ctx.Err() != nil {
st.status, st.outcome = 499, reqlog.OutcomeInterrupted // 客户端走了,不算上游故障
} else {
st.status = http.StatusBadGateway
}
return nil, lastErr
}
// requestLevelFailFastKind 报告该类上游错误是否与账号无关(换号必然同样失败)。
// images 与 search 共用:出图/检索的域级模型路由(14401)、审核与参数错误都是
// 请求本身的属性,换号只会打满全池。chat 侧另有一套(各账号模型权限可能不同)。
func requestLevelFailFastKind(kind upstream.ErrKind) bool {
switch kind {
case upstream.ErrBadParams, upstream.ErrPromptTooLong, upstream.ErrImageInvalid,
upstream.ErrModelParamInvalid, upstream.ErrEmptyContent,
upstream.ErrContentBlocked, upstream.ErrModelBlocked:
return true
}
return false
}
// imageMode 流水行的 mode 列。
func imageMode(edit bool) string {
if edit {
return "edit"
}
return "image"
}
// recordImageUsage 把上游 data 里的用量落到三个既有的账:流水行(st)、成本账本
// (NoteModelCost)、用量时序(usage.Recorder)。上游 usage 缺失时只记成功、不编数。
//
// 额外记一份**分档实扣**(upstream.RecordImageCharge,尺寸×画质):两域计费模型不同
// (CN 每张固定 5.71,global 按输出图像 token 计费),混成单一均值会随用户选画质漂移,
// 面板必须能按档显示。尺寸/画质优先取上游回执(global 会回 size/quality),回执缺省
// 时回落请求体同名字段(CN 回执不带,但请求里带了)。
func recordImageUsage(h *Handler, st *chatStat, realm, uid, bare, modelRate string, data []byte, req map[string]any, start time.Time) {
st.status = http.StatusOK
st.outcome = "success"
var env struct {
Quality string `json:"quality"`
Size string `json:"size"`
Usage struct {
InputTokens int64 `json:"input_tokens"`
OutputTokens int64 `json:"output_tokens"`
TotalTokens int64 `json:"total_tokens"`
Credit float64 `json:"credit"`
ImageCounts int64 `json:"output_image_counts"`
ImageTokens int64 `json:"output_image_tokens"`
Coefficient float64 `json:"output_image_coefficient"`
} `json:"usage"`
}
_ = json.Unmarshal(data, &env) // 上游省略 usage 时零值:下面按「有没有真值」决定是否记账
u := env.Usage
st.promptTokens, st.completionTokens, st.totalTokens = u.InputTokens, u.OutputTokens, u.TotalTokens
if u.TotalTokens > 0 {
st.toks = int(u.TotalTokens)
}
if u.Credit > 0 {
st.credit, st.hasCredit = u.Credit, true
h.cfg.Pool.NoteModelCost(uid, bare, u.Credit, int(u.TotalTokens))
if h.cfg.Upstream != nil {
size := env.Size
if size == "" {
size, _ = req["size"].(string)
}
quality := env.Quality
if quality == "" {
quality, _ = req["quality"].(string)
}
h.cfg.Upstream.RecordImageCharge(realm, bare, size, quality, u.Credit, u.ImageTokens, u.Coefficient)
}
}
imgs := u.ImageCounts
if imgs == 0 {
imgs = 1
}
log.Printf("images %s model=%s: 出图 %d 张 credit=%.2f 用时=%s",
logfmt.Label(uid, st.nick), bare, imgs, u.Credit, time.Since(start).Round(time.Millisecond))
if h.cfg.Usage != nil {
h.cfg.Usage.Add(time.Now(), realm, uid, bare, usage.Delta{
PromptTokens: u.InputTokens,
HasPromptTokens: u.InputTokens > 0,
TotalTokens: u.TotalTokens,
HasTotal: u.TotalTokens > 0,
LatencyMs: time.Since(start).Milliseconds(),
HasLatency: true,
Credit: u.Credit,
HasCredit: u.Credit > 0,
ModelRate: modelRate,
}, u.TotalTokens > 0)
}
}
// imageRequest 解析请求体:JSON 原样用(只把 image 归一成数组);multipart
// (OpenAI SDK 的 images.edit)就地转成上游要的 JSON,图片转 data URL。
func imageRequest(r *http.Request, raw []byte, edit bool) (map[string]any, error) {
ct := r.Header.Get("Content-Type")
if strings.HasPrefix(ct, "multipart/form-data") {
if !edit {
return nil, errors.New("文生图请用 application/json(multipart 只用于图生图)")
}
return multipartToImageJSON(raw, ct)
}
var req map[string]any
if err := json.Unmarshal(raw, &req); err != nil {
return nil, errors.New("invalid JSON body")
}
if edit {
// OpenAI 的 images.edit 用 image(单值或数组);上游要 image 数组。
imgs, _ := req["image"].([]any)
if len(imgs) == 0 {
if one, ok := req["image"].(string); ok && one != "" {
imgs = []any{one}
}
}
if len(imgs) == 0 {
return nil, errors.New("图生图需要 image(data URL / URL,或 image 数组)")
}
req["image"] = imgs
}
return req, nil
}
// multipartToImageJSON multipart 表单 → 上游 JSON:文件字段转 data URL(image[] / mask),
// 其余字段按字符串收(n 转数字)。
func multipartToImageJSON(raw []byte, ct string) (map[string]any, error) {
br := multipart.NewReader(strings.NewReader(string(raw)), boundaryOf(ct))
form, err := br.ReadForm(int64(len(raw)) + 1024)
if err != nil {
return nil, fmt.Errorf("解析 multipart 失败: %w", err)
}
out := map[string]any{}
for k, vs := range form.Value {
if len(vs) == 0 {
continue
}
if k == "n" {
if n, err := strconv.Atoi(vs[0]); err == nil {
out[k] = n
continue
}
}
out[k] = vs[0]
}
for field, files := range form.File {
var list []any
for _, fh := range files {
du, err := fileToDataURL(fh)
if err != nil {
return nil, err
}
list = append(list, du)
}
switch field {
case "mask":
out["mask"] = list[0]
case "image", "images":
out["image"] = list
default:
out[field] = list
}
}
if _, ok := out["image"]; !ok {
return nil, errors.New("图生图需要 image 文件")
}
return out, nil
}
// fileToDataURL 读一个上传文件并包成 data URL(上游 edits 的入参形态,实测接受)。
func fileToDataURL(fh *multipart.FileHeader) (string, error) {
f, err := fh.Open()
if err != nil {
return "", err
}
defer f.Close()
b, err := io.ReadAll(io.LimitReader(f, 8<<20)) // 8MB 上限:上游对超大 base64 会拒
if err != nil {
return "", err
}
ct := fh.Header.Get("Content-Type")
if ct == "" {
ct = "image/png"
}
return "data:" + ct + ";base64," + base64.StdEncoding.EncodeToString(b), nil
}
// b64JSONImages 把 data[].url 换成 data[].b64_json(OpenAI images 的 response_format)。
//
// 上游无视这个参数、永远回签名直链(2026-11-05 实测 response_format=b64_json 仍回 url),
// 所以只能在网关这一层转。取图失败就保留 url:图已经出了、也已经扣费,不能因为转码失败
// 把成品丢掉。回读走 media_fetch.go 的收口(只认产物域、不跟重定向、超限报错不截断),
// 这些都归入「取图失败」。
func b64JSONImages(ctx context.Context, data []byte) []byte {
var obj map[string]any
if json.Unmarshal(data, &obj) != nil {
return data
}
items, _ := obj["data"].([]any)
changed := false
for _, it := range items {
m, ok := it.(map[string]any)
if !ok {
continue
}
u, _ := m["url"].(string)
if u == "" {
continue
}
raw, err := fetchMedia(ctx, u, mediaFetchMax)
if err != nil {
log.Printf("images: response_format=b64_json 取图失败,保留直链: %v", err)
continue
}
m["b64_json"] = base64.StdEncoding.EncodeToString(raw)
delete(m, "url") // 规范里两者二选一,给了 b64 就不该再给 url
changed = true
}
if !changed {
return data
}
out, err := json.Marshal(obj)
if err != nil {
return data
}
return out
}
// boundaryOf 从 Content-Type 里取 multipart boundary。
func boundaryOf(ct string) string {
for _, part := range strings.Split(ct, ";") {
part = strings.TrimSpace(part)
if strings.HasPrefix(part, "boundary=") {
return strings.Trim(part[len("boundary="):], `"`)
}
}
return ""
}