File size: 9,250 Bytes
e48a2d8
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
// embeddings.go POST /v1/embeddings:OpenAI 兼容嵌入端点(实验特性,默认关闭)。
//
// 上游嵌入与对话是两套注册表(/v3/config 不含嵌入模型),实测唯一可用的是 bge-m3
// (1024 维)。因此本端点:
//   - 默认关闭:关着时回 403 embeddings_disabled(不是 404——功能存在,只是没开)。
//     开关是 features.embeddings_enabled,面板保存后热生效(livecfg 快照)。
//   - 模型名原样透传给上游,不替客户端改模型;未知模型由上游回 11351,本端映射成
//     OpenAI 语义的 404 model_not_found,并在文案里点出已知可用模型。
//   - 回程把上游 data[] 补齐 OpenAI 契约(object/index);条数与输入不符时宁可不返回,
//     也不能错位配对(向量错位比报错更难查)。
//   - 取号与失败处置与 /v1/search、/v1/images 同一套:单次取号、换号上限 3、
//     请求级错误(参数/内容/模型)fail-fast 不烧全池。
package server

import (
	"encoding/json"
	"errors"
	"fmt"
	"io"
	"log"
	"math"
	"net/http"
	"strconv"
	"strings"

	"github.com/misakano7545/workbuddy2api-panel/internal/logfmt"
	"github.com/misakano7545/workbuddy2api-panel/internal/proxypool"
	"github.com/misakano7545/workbuddy2api-panel/internal/upstream"
)

// embeddingsAttempts 失败换号上限(与 search/images 同量级)。
const embeddingsAttempts = 3

type embeddingsRequest struct {
	Model string `json:"model"`
	// Input 支持 OpenAI 的两种常用形态:单条字符串 / 字符串数组。
	// 分词数组([][]int)不接——上游只认文本,转发无意义。
	Input any `json:"input"`
	// Realm 可选,直接指定取号域(优先于 model 前缀)。
	Realm string `json:"realm"`
}

// normalizeEmbeddingInput 把 input 归一成字符串数组。
// 空串与空数组一律报错:上游对空输入没有有意义的行为,交给它只会换来一条难懂的 500。
func normalizeEmbeddingInput(v any) ([]string, error) {
	switch t := v.(type) {
	case nil:
		return nil, errors.New("缺少 input 字段")
	case string:
		if t == "" {
			return nil, errors.New("input 不能为空")
		}
		return []string{t}, nil
	case []any:
		if len(t) == 0 {
			return nil, errors.New("input 不能为空数组")
		}
		out := make([]string, 0, len(t))
		for i, item := range t {
			s, ok := item.(string)
			if !ok {
				return nil, fmt.Errorf("input[%d] 必须是字符串", i)
			}
			if s == "" {
				return nil, fmt.Errorf("input[%d] 不能为空串", i)
			}
			out = append(out, s)
		}
		return out, nil
	default:
		return nil, errors.New("input 只支持字符串或字符串数组")
	}
}

// normalizeEmbeddingsResponse 把上游原文补成 OpenAI 契约:
// data[i] 必须有 object="embedding" 与下标记;顶层 object="list"。
// 上游缺 index 时按数组顺序补(上游返回顺序即输入顺序,这是 OpenAI 的约定)。
// 条数与输入数不符时返回错误——错位配对比报错更难查。
func normalizeEmbeddingsResponse(raw []byte, want int) ([]byte, error) {
	var obj map[string]json.RawMessage
	if err := json.Unmarshal(raw, &obj); err != nil {
		return nil, fmt.Errorf("上游响应不是 JSON: %w", err)
	}
	var items []map[string]any
	if err := json.Unmarshal(obj["data"], &items); err != nil {
		return nil, errors.New("上游响应缺少 data 向量数组")
	}
	if len(items) != want {
		return nil, fmt.Errorf("上游返回 %d 条向量,与输入 %d 条不符", len(items), want)
	}
	out := make([]map[string]any, len(items))
	seen := make(map[int]bool, len(items))
	for i, it := range items {
		vector, ok := it["embedding"].([]any)
		if !ok || len(vector) == 0 {
			return nil, fmt.Errorf("上游 data[%d] 缺少非空数值向量", i)
		}
		for _, value := range vector {
			if _, ok := value.(float64); !ok {
				return nil, fmt.Errorf("上游 data[%d] 向量含非数值元素", i)
			}
		}
		index := i
		if value, present := it["index"]; present {
			n, ok := value.(float64)
			if !ok || n < 0 || n >= float64(want) || math.Trunc(n) != n {
				return nil, fmt.Errorf("上游 data[%d] 下标无效", i)
			}
			index = int(n)
		}
		if seen[index] {
			return nil, fmt.Errorf("上游向量下标 %d 重复", index)
		}
		seen[index] = true
		it["object"] = "embedding"
		it["index"] = index
		out[i] = it
	}
	data, err := json.Marshal(out)
	if err != nil {
		return nil, err
	}
	obj["data"] = data
	obj["object"] = json.RawMessage(`"list"`)
	// 其余字段(model / usage / 未来新增)原样保留。
	return json.Marshal(obj)
}

func (h *Handler) embeddings(w http.ResponseWriter, r *http.Request) {
	if !h.loadLive().EmbeddingsEnabled {
		writeOpenAIError(w, http.StatusForbidden, "embeddings_disabled",
			"嵌入端点未开启:请在面板配置里打开 features.embeddings_enabled(默认关闭)")
		return
	}
	raw, err := io.ReadAll(io.LimitReader(r.Body, (8<<20)+1))
	if err != nil {
		writeOpenAIError(w, http.StatusBadRequest, "invalid_request", "read body: "+err.Error())
		return
	}
	if len(raw) > 8<<20 {
		writeOpenAIError(w, http.StatusRequestEntityTooLarge, "invalid_request", "request body exceeds 8 MiB")
		return
	}
	var req embeddingsRequest
	if err := json.Unmarshal(raw, &req); err != nil {
		writeOpenAIError(w, http.StatusBadRequest, "invalid_request", "invalid json: "+err.Error())
		return
	}
	model := strings.TrimSpace(req.Model)
	if model == "" {
		writeOpenAIError(w, http.StatusBadRequest, "invalid_request", "model is required")
		return
	}
	inputs, err := normalizeEmbeddingInput(req.Input)
	if err != nil {
		writeOpenAIError(w, http.StatusBadRequest, "invalid_request", err.Error())
		return
	}

	// 域:realm 显式优先,其次模型自带前缀(cn: / global:),都没有 → cn。
	// 与对话不同,**剥掉**前缀再发给上游:上游目录里的模型 id 不带域前缀(bge-m3)。
	realm, bare := resolveModel(model)
	if req.Realm != "" {
		realm = req.Realm
	}
	if realm != "global" {
		realm = "cn"
	}
	if bare == "" {
		bare = model
	}
	if !h.allowedModel(realm, bare) || h.hiddenModel(realm, bare) {
		writeOpenAIError(w, http.StatusBadRequest, "model_unavailable", "model is unavailable by gateway configuration, try another model")
		return
	}

	tried := map[string]bool{}
	var lastErr error
	for attempt := 0; attempt < embeddingsAttempts; attempt++ {
		a := h.cfg.Pool.PickExcludingForRealm(tried, "", realm)
		if a == nil {
			break
		}
		tried[a.UID] = true
		data, err := h.cfg.Upstream.Embeddings(r.Context(), a, bare, inputs)
		if err == nil {
			out, nerr := normalizeEmbeddingsResponse(data, len(inputs))
			if nerr != nil {
				// 形状不对是上游的问题,但换号大概率一样:直接 502,不烧池。
				log.Printf("embeddings %s: 响应形状异常: %v", logfmt.Label(a.UID, a.Nickname), nerr)
				writeOpenAIError(w, http.StatusBadGateway, "upstream_error", nerr.Error())
				return
			}
			w.Header().Set("Content-Type", "application/json")
			_, _ = w.Write(out)
			return
		}
		lastErr = err
		if proxypool.IsError(err) {
			break
		}
		// 模型不存在:换号无意义(注册表是按模型不是按账号),且要给出 OpenAI 的 404 语义。
		if errors.Is(err, upstream.ErrEmbeddingModelNotFound) {
			writeOpenAIError(w, http.StatusNotFound, "model_not_found",
				fmt.Sprintf("嵌入模型 %q 不存在,当前上游嵌入模型仅支持 %q", bare, upstream.EmbeddingModelBGE))
			return
		}
		var ue *upstream.Error
		if errors.As(err, &ue) {
			// 6020/6021 渠道级队列:上游对本形态本身回 429(6020 带 data.retry_after)。
			// 与 chat 链路同口径(PR #108):429 + Retry-After,不换号(全局队列,换谁都撞),
			// 也不罚号(applyErrorPolicy 的 ErrUpstreamBusy 分支零动作)。
			if ue.Kind == upstream.ErrUpstreamBusy {
				if ue.RetryAfter > 0 {
					w.Header().Set("Retry-After", strconv.Itoa(int(math.Ceil(ue.RetryAfter.Seconds()))))
				}
				writeOpenAIError(w, http.StatusTooManyRequests, "upstream_busy", ue.Msg)
				return
			}
			h.applyErrorPolicy(a.UID, ue.Kind, ue.Msg, "", ue)
			// 请求级错误(参数/内容/模型权限):换号必然同样被拒,fail-fast 保住池子。
			if requestLevelFailFastKind(ue.Kind) {
				status := ue.Status
				if status < 400 {
					status = http.StatusBadRequest
				}
				log.Printf("embeddings realm=%s: 请求级错误 kind=%v,不再换号", realm, ue.Kind)
				writeOpenAIError(w, status, "upstream_error", ue.Msg)
				return
			}
		}
		log.Printf("embeddings %s realm=%s attempt=%d: %v", logfmt.Label(a.UID, a.Nickname), realm, attempt+1, err)
	}

	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 账号", realm)
	case errors.As(lastErr, &ue) && ue.Status >= 400:
		status = ue.Status
	}
	log.Printf("embeddings realm=%s: 全部尝试失败(%d 个账号):%v", realm, len(tried), lastErr)
	writeOpenAIError(w, status, code, lastErr.Error())
}