feat: support cohere rerank

relay/channel/cohere/adaptor.go

@@ -8,16 +8,24 @@ import (
 	"one-api/dto"
 	"one-api/relay/channel"
 	relaycommon "one-api/relay/common"
+	"one-api/relay/constant"
 )
 
 type Adaptor struct {
 }
 
+func (a *Adaptor) InitRerank(info *relaycommon.RelayInfo, request dto.RerankRequest) {
+}
+
 func (a *Adaptor) Init(info *relaycommon.RelayInfo, request dto.GeneralOpenAIRequest) {
 }
 
 func (a *Adaptor) GetRequestURL(info *relaycommon.RelayInfo) (string, error) {
-	return fmt.Sprintf("%s/v1/chat", info.BaseUrl), nil
+	if info.RelayMode == constant.RelayModeRerank {
+		return fmt.Sprintf("%s/v1/rerank", info.BaseUrl), nil
+	} else {
+		return fmt.Sprintf("%s/v1/chat", info.BaseUrl), nil
+	}
 }
 
 func (a *Adaptor) SetupRequestHeader(c *gin.Context, req *http.Request, info *relaycommon.RelayInfo) error {
@@ -34,11 +42,19 @@ func (a *Adaptor) DoRequest(c *gin.Context, info *relaycommon.RelayInfo, request
 	return channel.DoApiRequest(a, c, info, requestBody)
 }
 
+func (a *Adaptor) ConvertRerankRequest(c *gin.Context, relayMode int, request dto.RerankRequest) (any, error) {
+	return requestConvertRerank2Cohere(request), nil
+}
+
 func (a *Adaptor) DoResponse(c *gin.Context, resp *http.Response, info *relaycommon.RelayInfo) (usage *dto.Usage, err *dto.OpenAIErrorWithStatusCode) {
-	if info.IsStream {
-		err, usage = cohereStreamHandler(c, resp, info)
+	if info.RelayMode == constant.RelayModeRerank {
+		err, usage = cohereRerankHandler(c, resp, info)
 	} else {
-		err, usage = cohereHandler(c, resp, info.UpstreamModelName, info.PromptTokens)
+		if info.IsStream {
+			err, usage = cohereStreamHandler(c, resp, info)
+		} else {
+			err, usage = cohereHandler(c, resp, info.UpstreamModelName, info.PromptTokens)
+		}
 	}
 	return
 }

relay/channel/cohere/constant.go

@@ -2,6 +2,7 @@ package cohere
 
 var ModelList = []string{
 	"command-r", "command-r-plus", "command-light", "command-light-nightly", "command", "command-nightly",
+	"rerank-english-v3.0", "rerank-multilingual-v3.0", "rerank-english-v2.0", "rerank-multilingual-v2.0",
 }
 
 var ChannelName = "cohere"

relay/channel/cohere/dto.go

@@ -1,5 +1,7 @@
 package cohere
 
+import "one-api/dto"
+
 type CohereRequest struct {
 	Model       string        `json:"model"`
 	ChatHistory []ChatHistory `json:"chat_history"`
@@ -28,6 +30,19 @@ type CohereResponseResult struct {
 	Meta         CohereMeta `json:"meta"`
 }
 
+type CohereRerankRequest struct {
+	Documents       []any  `json:"documents"`
+	Query           string `json:"query"`
+	Model           string `json:"model"`
+	TopN            int    `json:"top_n"`
+	ReturnDocuments bool   `json:"return_documents"`
+}
+
+type CohereRerankResponseResult struct {
+	Results []dto.RerankResponseDocument `json:"results"`
+	Meta    CohereMeta                   `json:"meta"`
+}
+
 type CohereMeta struct {
 	//Tokens CohereTokens `json:"tokens"`
 	BilledUnits CohereBilledUnits `json:"billed_units"`

relay/channel/cohere/relay-cohere.go

@@ -47,6 +47,20 @@ func requestOpenAI2Cohere(textRequest dto.GeneralOpenAIRequest) *CohereRequest {
 	return &cohereReq
 }
 
+func requestConvertRerank2Cohere(rerankRequest dto.RerankRequest) *CohereRerankRequest {
+	cohereReq := CohereRerankRequest{
+		Query:           rerankRequest.Query,
+		Documents:       rerankRequest.Documents,
+		Model:           rerankRequest.Model,
+		TopN:            rerankRequest.TopN,
+		ReturnDocuments: true,
+	}
+	for _, doc := range rerankRequest.Documents {
+		cohereReq.Documents = append(cohereReq.Documents, doc)
+	}
+	return &cohereReq
+}
+
 func stopReasonCohere2OpenAI(reason string) string {
 	switch reason {
 	case "COMPLETE":
@@ -194,3 +208,42 @@ func cohereHandler(c *gin.Context, resp *http.Response, modelName string, prompt
 	_, err = c.Writer.Write(jsonResponse)
 	return nil, &usage
 }
+
+func cohereRerankHandler(c *gin.Context, resp *http.Response, info *relaycommon.RelayInfo) (*dto.OpenAIErrorWithStatusCode, *dto.Usage) {
+	responseBody, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return service.OpenAIErrorWrapper(err, "read_response_body_failed", http.StatusInternalServerError), nil
+	}
+	err = resp.Body.Close()
+	if err != nil {
+		return service.OpenAIErrorWrapper(err, "close_response_body_failed", http.StatusInternalServerError), nil
+	}
+	var cohereResp CohereRerankResponseResult
+	err = json.Unmarshal(responseBody, &cohereResp)
+	if err != nil {
+		return service.OpenAIErrorWrapper(err, "unmarshal_response_body_failed", http.StatusInternalServerError), nil
+	}
+	usage := dto.Usage{}
+	if cohereResp.Meta.BilledUnits.InputTokens == 0 {
+		usage.PromptTokens = info.PromptTokens
+		usage.CompletionTokens = 0
+		usage.TotalTokens = info.PromptTokens
+	} else {
+		usage.PromptTokens = cohereResp.Meta.BilledUnits.InputTokens
+		usage.CompletionTokens = cohereResp.Meta.BilledUnits.OutputTokens
+		usage.TotalTokens = cohereResp.Meta.BilledUnits.InputTokens + cohereResp.Meta.BilledUnits.OutputTokens
+	}
+
+	var rerankResp dto.RerankResponse
+	rerankResp.Results = cohereResp.Results
+	rerankResp.Usage = usage
+
+	jsonResponse, err := json.Marshal(rerankResp)
+	if err != nil {
+		return service.OpenAIErrorWrapper(err, "marshal_response_body_failed", http.StatusInternalServerError), nil
+	}
+	c.Writer.Header().Set("Content-Type", "application/json")
+	c.Writer.WriteHeader(resp.StatusCode)
+	_, err = c.Writer.Write(jsonResponse)
+	return nil, &usage
+}