119 lines
3.5 KiB
Go
119 lines
3.5 KiB
Go
package gateway
|
|
|
|
import (
|
|
"errors"
|
|
"fmt"
|
|
"io"
|
|
"net/http"
|
|
|
|
"gitea.rutua.cn/kate522/CrossRelay/internal/chatcmpl"
|
|
"gitea.rutua.cn/kate522/CrossRelay/internal/responses"
|
|
)
|
|
|
|
// handleResponses serves POST /v1/responses in both streaming and
|
|
// non-streaming modes.
|
|
func (s *Server) handleResponses(w http.ResponseWriter, r *http.Request) {
|
|
var req responses.Request
|
|
if err := decodeJSON(r, &req, 64<<20); err != nil {
|
|
writeResponsesError(w, http.StatusBadRequest, "invalid_request_error", "invalid request body: "+err.Error())
|
|
return
|
|
}
|
|
provider := s.store.ActiveCodex()
|
|
if provider == nil {
|
|
writeResponsesError(w, http.StatusBadRequest, "invalid_request_error",
|
|
"no active provider: activate one in the CrossRelay app")
|
|
return
|
|
}
|
|
model := provider.ResolveModel(req.Model)
|
|
|
|
chatReq, err := responses.ConvertRequest(&req, model)
|
|
if err != nil {
|
|
writeResponsesError(w, http.StatusBadRequest, "invalid_request_error", err.Error())
|
|
return
|
|
}
|
|
|
|
rec := recordFrom(r)
|
|
rec.update(func(e *LogEntry) {
|
|
e.Model = model
|
|
e.InputTokens = responses.EstimateTokens(chatReq)
|
|
})
|
|
|
|
client := chatcmpl.NewClient(provider.BaseURL, provider.APIKey)
|
|
if req.Stream {
|
|
s.handleResponsesStream(w, r, client, chatReq, &req, model, rec)
|
|
return
|
|
}
|
|
|
|
resp, err := client.Create(r.Context(), chatReq)
|
|
if err != nil {
|
|
s.failUpstreamResponses(w, rec, err)
|
|
return
|
|
}
|
|
out := responses.ConvertResponse(resp, req.Model)
|
|
rec.update(func(e *LogEntry) {
|
|
if out.Usage != nil {
|
|
e.OutputTokens = out.Usage.OutputTokens
|
|
}
|
|
})
|
|
writeJSON(w, http.StatusOK, out)
|
|
}
|
|
|
|
// handleResponsesStream relays a Chat Completions SSE stream as
|
|
// Responses events.
|
|
func (s *Server) handleResponsesStream(w http.ResponseWriter, r *http.Request, client *chatcmpl.Client,
|
|
chatReq *chatcmpl.Request, req *responses.Request, model string, rec *record) {
|
|
|
|
resp, err := client.CreateStream(r.Context(), chatReq)
|
|
if err != nil {
|
|
s.failUpstreamResponses(w, rec, err)
|
|
return
|
|
}
|
|
defer resp.Body.Close()
|
|
|
|
conv := responses.NewStreamConverter(w, req.Model, responses.EstimateTokens(chatReq))
|
|
if err := conv.WriteStart(); err != nil {
|
|
return
|
|
}
|
|
stream := chatcmpl.NewStream(resp.Body)
|
|
for {
|
|
chunk, err := stream.Next()
|
|
if errors.Is(err, io.EOF) {
|
|
break
|
|
}
|
|
if err != nil {
|
|
rec.update(func(e *LogEntry) { e.Error = err.Error() })
|
|
conv.WriteError("api_error", err.Error())
|
|
return
|
|
}
|
|
if err := conv.OnChunk(chunk); err != nil {
|
|
rec.update(func(e *LogEntry) { e.Error = err.Error() })
|
|
conv.WriteError("api_error", err.Error())
|
|
return
|
|
}
|
|
}
|
|
if err := conv.Finish(); err != nil {
|
|
rec.update(func(e *LogEntry) { e.Error = err.Error() })
|
|
}
|
|
}
|
|
|
|
// failUpstreamResponses maps an upstream failure onto a Responses
|
|
// error envelope.
|
|
func (s *Server) failUpstreamResponses(w http.ResponseWriter, rec *record, err error) {
|
|
rec.update(func(e *LogEntry) { e.Error = err.Error() })
|
|
var ue *chatcmpl.UpstreamError
|
|
if errors.As(err, &ue) {
|
|
switch {
|
|
case ue.StatusCode == http.StatusUnauthorized || ue.StatusCode == http.StatusForbidden:
|
|
writeResponsesError(w, http.StatusUnauthorized, "authentication_error", ue.Message)
|
|
case ue.StatusCode == http.StatusTooManyRequests:
|
|
writeResponsesError(w, http.StatusTooManyRequests, "rate_limit_error", ue.Message)
|
|
case ue.StatusCode == http.StatusBadRequest:
|
|
writeResponsesError(w, http.StatusBadRequest, "invalid_request_error", ue.Message)
|
|
default:
|
|
writeResponsesError(w, http.StatusBadGateway, "api_error", ue.Message)
|
|
}
|
|
return
|
|
}
|
|
writeResponsesError(w, http.StatusBadGateway, "api_error", fmt.Sprintf("upstream request failed: %v", err))
|
|
}
|