Merge branch 'main' into main

.github/workflows/docker-image-amd64.yml

@@ -18,20 +18,20 @@ jobs:
       contents: read
       contents: read
     steps:
     steps:
       - name: Check out the repo
       - name: Check out the repo
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
 
 
       - name: Save version info
       - name: Save version info
         run: |
         run: |
           git describe --tags > VERSION 
           git describe --tags > VERSION 
 
 
       - name: Log in to Docker Hub
       - name: Log in to Docker Hub
-        uses: docker/login-action@v2
+        uses: docker/login-action@v3
         with:
         with:
           username: ${{ secrets.DOCKERHUB_USERNAME }}
           username: ${{ secrets.DOCKERHUB_USERNAME }}
           password: ${{ secrets.DOCKERHUB_TOKEN }}
           password: ${{ secrets.DOCKERHUB_TOKEN }}
 
 
       - name: Log in to the Container registry
       - name: Log in to the Container registry
-        uses: docker/login-action@v2
+        uses: docker/login-action@v3
         with:
         with:
           registry: ghcr.io
           registry: ghcr.io
           username: ${{ github.actor }}
           username: ${{ github.actor }}
@@ -39,14 +39,14 @@ jobs:
 
 
       - name: Extract metadata (tags, labels) for Docker
       - name: Extract metadata (tags, labels) for Docker
         id: meta
         id: meta
-        uses: docker/metadata-action@v4
+        uses: docker/metadata-action@v5
         with:
         with:
           images: |
           images: |
             calciumion/new-api
             calciumion/new-api
             ghcr.io/${{ github.repository }}
             ghcr.io/${{ github.repository }}
 
 
       - name: Build and push Docker images
       - name: Build and push Docker images
-        uses: docker/build-push-action@v3
+        uses: docker/build-push-action@v5
         with:
         with:
           context: .
           context: .
           push: true
           push: true

.github/workflows/docker-image-arm64.yml

@@ -4,7 +4,6 @@ on:
   push:
   push:
     tags:
     tags:
       - '*'
       - '*'
-      - '!*-alpha*'
   workflow_dispatch:
   workflow_dispatch:
     inputs:
     inputs:
       name:
       name:
@@ -19,26 +18,26 @@ jobs:
       contents: read
       contents: read
     steps:
     steps:
       - name: Check out the repo
       - name: Check out the repo
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
 
 
       - name: Save version info
       - name: Save version info
         run: |
         run: |
           git describe --tags > VERSION 
           git describe --tags > VERSION 
 
 
       - name: Set up QEMU
       - name: Set up QEMU
-        uses: docker/setup-qemu-action@v2
+        uses: docker/setup-qemu-action@v3
 
 
       - name: Set up Docker Buildx
       - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v2
+        uses: docker/setup-buildx-action@v3
 
 
       - name: Log in to Docker Hub
       - name: Log in to Docker Hub
-        uses: docker/login-action@v2
+        uses: docker/login-action@v3
         with:
         with:
           username: ${{ secrets.DOCKERHUB_USERNAME }}
           username: ${{ secrets.DOCKERHUB_USERNAME }}
           password: ${{ secrets.DOCKERHUB_TOKEN }}
           password: ${{ secrets.DOCKERHUB_TOKEN }}
 
 
       - name: Log in to the Container registry
       - name: Log in to the Container registry
-        uses: docker/login-action@v2
+        uses: docker/login-action@v3
         with:
         with:
           registry: ghcr.io
           registry: ghcr.io
           username: ${{ github.actor }}
           username: ${{ github.actor }}
@@ -46,14 +45,14 @@ jobs:
 
 
       - name: Extract metadata (tags, labels) for Docker
       - name: Extract metadata (tags, labels) for Docker
         id: meta
         id: meta
-        uses: docker/metadata-action@v4
+        uses: docker/metadata-action@v5
         with:
         with:
           images: |
           images: |
             calciumion/new-api
             calciumion/new-api
             ghcr.io/${{ github.repository }}
             ghcr.io/${{ github.repository }}
 
 
       - name: Build and push Docker images
       - name: Build and push Docker images
-        uses: docker/build-push-action@v3
+        uses: docker/build-push-action@v5
         with:
         with:
           context: .
           context: .
           platforms: linux/amd64,linux/arm64
           platforms: linux/amd64,linux/arm64

common/constants.go

@@ -234,6 +234,7 @@ const (
 	ChannelTypeMokaAI         = 44
 	ChannelTypeMokaAI         = 44
 	ChannelTypeVolcEngine     = 45
 	ChannelTypeVolcEngine     = 45
 	ChannelTypeBaiduV2        = 46
 	ChannelTypeBaiduV2        = 46
+	ChannelTypeXinference     = 47
 	ChannelTypeDummy          // this one is only for count, do not add any channel after this
 	ChannelTypeDummy          // this one is only for count, do not add any channel after this
 
 
 )
 )
@@ -286,4 +287,5 @@ var ChannelBaseURLs = []string{
 	"https://api.moka.ai",                       //44
 	"https://api.moka.ai",                       //44
 	"https://ark.cn-beijing.volces.com",         //45
 	"https://ark.cn-beijing.volces.com",         //45
 	"https://qianfan.baidubce.com",              //46
 	"https://qianfan.baidubce.com",              //46
+	"",                                          //47
 }
 }

common/custom-event.go

@@ -44,7 +44,7 @@ var fieldReplacer = strings.NewReplacer(
 	"\r", "\\r")
 	"\r", "\\r")
 
 
 var dataReplacer = strings.NewReplacer(
 var dataReplacer = strings.NewReplacer(
-	"\n", "\ndata:",
+	"\n", "\n",
 	"\r", "\\r")
 	"\r", "\\r")
 
 
 type CustomEvent struct {
 type CustomEvent struct {

controller/channel-test.go

@@ -107,7 +107,7 @@ func testChannel(channel *model.Channel, testModel string) (err error, openAIErr
 
 
 	adaptor.Init(info)
 	adaptor.Init(info)
 
 
-	convertedRequest, err := adaptor.ConvertRequest(c, info, request)
+	convertedRequest, err := adaptor.ConvertOpenAIRequest(c, info, request)
 	if err != nil {
 	if err != nil {
 		return err, nil
 		return err, nil
 	}
 	}

controller/relay.go

@@ -148,6 +148,50 @@ func WssRelay(c *gin.Context) {
 	}
 	}
 }
 }
 
 
+func RelayClaude(c *gin.Context) {
+	//relayMode := constant.Path2RelayMode(c.Request.URL.Path)
+	requestId := c.GetString(common.RequestIdKey)
+	group := c.GetString("group")
+	originalModel := c.GetString("original_model")
+	var claudeErr *dto.ClaudeErrorWithStatusCode
+
+	for i := 0; i <= common.RetryTimes; i++ {
+		channel, err := getChannel(c, group, originalModel, i)
+		if err != nil {
+			common.LogError(c, err.Error())
+			claudeErr = service.ClaudeErrorWrapperLocal(err, "get_channel_failed", http.StatusInternalServerError)
+			break
+		}
+
+		claudeErr = claudeRequest(c, channel)
+
+		if claudeErr == nil {
+			return // 成功处理请求，直接返回
+		}
+
+		openaiErr := service.ClaudeErrorToOpenAIError(claudeErr)
+
+		go processChannelError(c, channel.Id, channel.Type, channel.Name, channel.GetAutoBan(), openaiErr)
+
+		if !shouldRetry(c, openaiErr, common.RetryTimes-i) {
+			break
+		}
+	}
+	useChannel := c.GetStringSlice("use_channel")
+	if len(useChannel) > 1 {
+		retryLogStr := fmt.Sprintf("重试：%s", strings.Trim(strings.Join(strings.Fields(fmt.Sprint(useChannel)), "->"), "[]"))
+		common.LogInfo(c, retryLogStr)
+	}
+
+	if claudeErr != nil {
+		claudeErr.Error.Message = common.MessageWithRequestId(claudeErr.Error.Message, requestId)
+		c.JSON(claudeErr.StatusCode, gin.H{
+			"type":  "error",
+			"error": claudeErr.Error,
+		})
+	}
+}
+
 func relayRequest(c *gin.Context, relayMode int, channel *model.Channel) *dto.OpenAIErrorWithStatusCode {
 func relayRequest(c *gin.Context, relayMode int, channel *model.Channel) *dto.OpenAIErrorWithStatusCode {
 	addUsedChannel(c, channel.Id)
 	addUsedChannel(c, channel.Id)
 	requestBody, _ := common.GetRequestBody(c)
 	requestBody, _ := common.GetRequestBody(c)
@@ -162,6 +206,13 @@ func wssRequest(c *gin.Context, ws *websocket.Conn, relayMode int, channel *mode
 	return relay.WssHelper(c, ws)
 	return relay.WssHelper(c, ws)
 }
 }
 
 
+func claudeRequest(c *gin.Context, channel *model.Channel) *dto.ClaudeErrorWithStatusCode {
+	addUsedChannel(c, channel.Id)
+	requestBody, _ := common.GetRequestBody(c)
+	c.Request.Body = io.NopCloser(bytes.NewBuffer(requestBody))
+	return relay.ClaudeHelper(c)
+}
+
 func addUsedChannel(c *gin.Context, channelId int) {
 func addUsedChannel(c *gin.Context, channelId int) {
 	useChannel := c.GetStringSlice("use_channel")
 	useChannel := c.GetStringSlice("use_channel")
 	useChannel = append(useChannel, fmt.Sprintf("%d", channelId))
 	useChannel = append(useChannel, fmt.Sprintf("%d", channelId))

dto/claude.go

+package dto
+
+import "encoding/json"
+
+type ClaudeMetadata struct {
+	UserId string `json:"user_id"`
+}
+
+type ClaudeMediaMessage struct {
+	Type        string               `json:"type"`
+	Text        *string              `json:"text,omitempty"`
+	Model       string               `json:"model,omitempty"`
+	Source      *ClaudeMessageSource `json:"source,omitempty"`
+	Usage       *ClaudeUsage         `json:"usage,omitempty"`
+	StopReason  *string              `json:"stop_reason,omitempty"`
+	PartialJson *string              `json:"partial_json,omitempty"`
+	Role        string               `json:"role,omitempty"`
+	Thinking    string               `json:"thinking,omitempty"`
+	Signature   string               `json:"signature,omitempty"`
+	Delta       string               `json:"delta,omitempty"`
+	// tool_calls
+	Id        string          `json:"id,omitempty"`
+	Name      string          `json:"name,omitempty"`
+	Input     any             `json:"input,omitempty"`
+	Content   json.RawMessage `json:"content,omitempty"`
+	ToolUseId string          `json:"tool_use_id,omitempty"`
+}
+
+func (c *ClaudeMediaMessage) SetText(s string) {
+	c.Text = &s
+}
+
+func (c *ClaudeMediaMessage) GetText() string {
+	if c.Text == nil {
+		return ""
+	}
+	return *c.Text
+}
+
+func (c *ClaudeMediaMessage) IsStringContent() bool {
+	var content string
+	return json.Unmarshal(c.Content, &content) == nil
+}
+
+func (c *ClaudeMediaMessage) GetStringContent() string {
+	var content string
+	if err := json.Unmarshal(c.Content, &content); err == nil {
+		return content
+	}
+	return ""
+}
+
+func (c *ClaudeMediaMessage) SetContent(content any) {
+	jsonContent, _ := json.Marshal(content)
+	c.Content = jsonContent
+}
+
+func (c *ClaudeMediaMessage) ParseMediaContent() []ClaudeMediaMessage {
+	var mediaContent []ClaudeMediaMessage
+	if err := json.Unmarshal(c.Content, &mediaContent); err == nil {
+		return mediaContent
+	}
+	return make([]ClaudeMediaMessage, 0)
+}
+
+type ClaudeMessageSource struct {
+	Type      string `json:"type"`
+	MediaType string `json:"media_type"`
+	Data      any    `json:"data"`
+}
+
+type ClaudeMessage struct {
+	Role    string `json:"role"`
+	Content any    `json:"content"`
+}
+
+func (c *ClaudeMessage) IsStringContent() bool {
+	_, ok := c.Content.(string)
+	return ok
+}
+
+func (c *ClaudeMessage) GetStringContent() string {
+	if c.IsStringContent() {
+		return c.Content.(string)
+	}
+	return ""
+}
+
+func (c *ClaudeMessage) SetStringContent(content string) {
+	c.Content = content
+}
+
+func (c *ClaudeMessage) ParseContent() ([]ClaudeMediaMessage, error) {
+	// map content to []ClaudeMediaMessage
+	// parse to json
+	jsonContent, _ := json.Marshal(c.Content)
+	var contentList []ClaudeMediaMessage
+	err := json.Unmarshal(jsonContent, &contentList)
+	if err != nil {
+		return make([]ClaudeMediaMessage, 0), err
+	}
+	return contentList, nil
+}
+
+type Tool struct {
+	Name        string                 `json:"name"`
+	Description string                 `json:"description,omitempty"`
+	InputSchema map[string]interface{} `json:"input_schema"`
+}
+
+type InputSchema struct {
+	Type       string `json:"type"`
+	Properties any    `json:"properties,omitempty"`
+	Required   any    `json:"required,omitempty"`
+}
+
+type ClaudeRequest struct {
+	Model             string          `json:"model"`
+	Prompt            string          `json:"prompt,omitempty"`
+	System            any             `json:"system,omitempty"`
+	Messages          []ClaudeMessage `json:"messages,omitempty"`
+	MaxTokens         uint            `json:"max_tokens,omitempty"`
+	MaxTokensToSample uint            `json:"max_tokens_to_sample,omitempty"`
+	StopSequences     []string        `json:"stop_sequences,omitempty"`
+	Temperature       *float64        `json:"temperature,omitempty"`
+	TopP              float64         `json:"top_p,omitempty"`
+	TopK              int             `json:"top_k,omitempty"`
+	//ClaudeMetadata    `json:"metadata,omitempty"`
+	Stream     bool      `json:"stream,omitempty"`
+	Tools      any       `json:"tools,omitempty"`
+	ToolChoice any       `json:"tool_choice,omitempty"`
+	Thinking   *Thinking `json:"thinking,omitempty"`
+}
+
+type Thinking struct {
+	Type         string `json:"type"`
+	BudgetTokens int    `json:"budget_tokens"`
+}
+
+func (c *ClaudeRequest) IsStringSystem() bool {
+	_, ok := c.System.(string)
+	return ok
+}
+
+func (c *ClaudeRequest) GetStringSystem() string {
+	if c.IsStringSystem() {
+		return c.System.(string)
+	}
+	return ""
+}
+
+func (c *ClaudeRequest) SetStringSystem(system string) {
+	c.System = system
+}
+
+func (c *ClaudeRequest) ParseSystem() []ClaudeMediaMessage {
+	// map content to []ClaudeMediaMessage
+	// parse to json
+	jsonContent, _ := json.Marshal(c.System)
+	var contentList []ClaudeMediaMessage
+	if err := json.Unmarshal(jsonContent, &contentList); err == nil {
+		return contentList
+	}
+	return make([]ClaudeMediaMessage, 0)
+}
+
+type ClaudeError struct {
+	Type    string `json:"type"`
+	Message string `json:"message"`
+}
+
+type ClaudeErrorWithStatusCode struct {
+	Error      ClaudeError `json:"error"`
+	StatusCode int         `json:"status_code"`
+	LocalError bool
+}
+
+type ClaudeResponse struct {
+	Id           string               `json:"id,omitempty"`
+	Type         string               `json:"type"`
+	Role         string               `json:"role,omitempty"`
+	Content      []ClaudeMediaMessage `json:"content,omitempty"`
+	Completion   string               `json:"completion,omitempty"`
+	StopReason   string               `json:"stop_reason,omitempty"`
+	Model        string               `json:"model,omitempty"`
+	Error        ClaudeError          `json:"error,omitempty"`
+	Usage        *ClaudeUsage         `json:"usage,omitempty"`
+	Index        *int                 `json:"index,omitempty"`
+	ContentBlock *ClaudeMediaMessage  `json:"content_block,omitempty"`
+	Delta        *ClaudeMediaMessage  `json:"delta,omitempty"`
+	Message      *ClaudeMediaMessage  `json:"message,omitempty"`
+}
+
+// set index
+func (c *ClaudeResponse) SetIndex(i int) {
+	c.Index = &i
+}
+
+// get index
+func (c *ClaudeResponse) GetIndex() int {
+	if c.Index == nil {
+		return 0
+	}
+	return *c.Index
+}
+
+type ClaudeUsage struct {
+	InputTokens              int `json:"input_tokens"`
+	CacheCreationInputTokens int `json:"cache_creation_input_tokens"`
+	CacheReadInputTokens     int `json:"cache_read_input_tokens"`
+	OutputTokens             int `json:"output_tokens"`
+}

dto/openai_response.go

 package dto
 package dto
 
 
-type TextResponseWithError struct {
-	Id      string                        `json:"id"`
-	Object  string                        `json:"object"`
-	Created int64                         `json:"created"`
-	Choices []OpenAITextResponseChoice    `json:"choices"`
-	Data    []OpenAIEmbeddingResponseItem `json:"data"`
-	Model   string                        `json:"model"`
-	Usage   `json:"usage"`
-	Error   OpenAIError `json:"error"`
-}
-
 type SimpleResponse struct {
 type SimpleResponse struct {
 	Usage   `json:"usage"`
 	Usage   `json:"usage"`
 	Error   OpenAIError                `json:"error"`
 	Error   OpenAIError                `json:"error"`
@@ -125,6 +114,20 @@ type ChatCompletionsStreamResponse struct {
 	Usage             *Usage                                `json:"usage"`
 	Usage             *Usage                                `json:"usage"`
 }
 }
 
 
+func (c *ChatCompletionsStreamResponse) IsToolCall() bool {
+	if len(c.Choices) == 0 {
+		return false
+	}
+	return len(c.Choices[0].Delta.ToolCalls) > 0
+}
+
+func (c *ChatCompletionsStreamResponse) GetFirstToolCall() *ToolCallResponse {
+	if c.IsToolCall() {
+		return &c.Choices[0].Delta.ToolCalls[0]
+	}
+	return nil
+}
+
 func (c *ChatCompletionsStreamResponse) Copy() *ChatCompletionsStreamResponse {
 func (c *ChatCompletionsStreamResponse) Copy() *ChatCompletionsStreamResponse {
 	choices := make([]ChatCompletionsStreamResponseChoice, len(c.Choices))
 	choices := make([]ChatCompletionsStreamResponseChoice, len(c.Choices))
 	copy(choices, c.Choices)
 	copy(choices, c.Choices)

dto/realtime.go

@@ -44,10 +44,11 @@ type RealtimeUsage struct {
 }
 }
 
 
 type InputTokenDetails struct {
 type InputTokenDetails struct {
-	CachedTokens int `json:"cached_tokens"`
-	TextTokens   int `json:"text_tokens"`
-	AudioTokens  int `json:"audio_tokens"`
-	ImageTokens  int `json:"image_tokens"`
+	CachedTokens         int `json:"cached_tokens"`
+	CachedCreationTokens int
+	TextTokens           int `json:"text_tokens"`
+	AudioTokens          int `json:"audio_tokens"`
+	ImageTokens          int `json:"image_tokens"`
 }
 }
 
 
 type OutputTokenDetails struct {
 type OutputTokenDetails struct {

go.mod

@@ -11,6 +11,7 @@ require (
 	github.com/aws/aws-sdk-go-v2/credentials v1.17.11
 	github.com/aws/aws-sdk-go-v2/credentials v1.17.11
 	github.com/aws/aws-sdk-go-v2/service/bedrockruntime v1.7.4
 	github.com/aws/aws-sdk-go-v2/service/bedrockruntime v1.7.4
 	github.com/bytedance/gopkg v0.0.0-20220118071334-3db87571198b
 	github.com/bytedance/gopkg v0.0.0-20220118071334-3db87571198b
+	github.com/bytedance/sonic v1.11.6
 	github.com/gin-contrib/cors v1.7.2
 	github.com/gin-contrib/cors v1.7.2
 	github.com/gin-contrib/gzip v0.0.6
 	github.com/gin-contrib/gzip v0.0.6
 	github.com/gin-contrib/sessions v0.0.5
 	github.com/gin-contrib/sessions v0.0.5
@@ -42,7 +43,6 @@ require (
 	github.com/aws/aws-sdk-go-v2/internal/configsources v1.3.5 // indirect
 	github.com/aws/aws-sdk-go-v2/internal/configsources v1.3.5 // indirect
 	github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.6.5 // indirect
 	github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.6.5 // indirect
 	github.com/aws/smithy-go v1.20.2 // indirect
 	github.com/aws/smithy-go v1.20.2 // indirect
-	github.com/bytedance/sonic v1.11.6 // indirect
 	github.com/bytedance/sonic/loader v0.1.1 // indirect
 	github.com/bytedance/sonic/loader v0.1.1 // indirect
 	github.com/cespare/xxhash/v2 v2.3.0 // indirect
 	github.com/cespare/xxhash/v2 v2.3.0 // indirect
 	github.com/cloudwego/base64x v0.1.4 // indirect
 	github.com/cloudwego/base64x v0.1.4 // indirect

middleware/auth.go

@@ -174,6 +174,14 @@ func TokenAuth() func(c *gin.Context) {
 			}
 			}
 			c.Request.Header.Set("Authorization", "Bearer "+key)
 			c.Request.Header.Set("Authorization", "Bearer "+key)
 		}
 		}
+		// 检查path包含/v1/messages
+		if strings.Contains(c.Request.URL.Path, "/v1/messages") {
+			// 从x-api-key中获取key
+			key := c.Request.Header.Get("x-api-key")
+			if key != "" {
+				c.Request.Header.Set("Authorization", "Bearer "+key)
+			}
+		}
 		key := c.Request.Header.Get("Authorization")
 		key := c.Request.Header.Get("Authorization")
 		parts := make([]string, 0)
 		parts := make([]string, 0)
 		key = strings.TrimPrefix(key, "Bearer ")
 		key = strings.TrimPrefix(key, "Bearer ")

model/main.go

 package model
 package model
 
 
 import (
 import (
-	"github.com/glebarez/sqlite"
-	"gorm.io/driver/mysql"
-	"gorm.io/driver/postgres"
-	"gorm.io/gorm"
 	"log"
 	"log"
 	"one-api/common"
 	"one-api/common"
 	"os"
 	"os"
 	"strings"
 	"strings"
 	"sync"
 	"sync"
 	"time"
 	"time"
+
+	"github.com/glebarez/sqlite"
+	"gorm.io/driver/mysql"
+	"gorm.io/driver/postgres"
+	"gorm.io/gorm"
 )
 )
 
 
 var groupCol string
 var groupCol string
@@ -60,7 +61,7 @@ func chooseDB(envName string) (*gorm.DB, error) {
 	}()
 	}()
 	dsn := os.Getenv(envName)
 	dsn := os.Getenv(envName)
 	if dsn != "" {
 	if dsn != "" {
-		if strings.HasPrefix(dsn, "postgres://") {
+		if strings.HasPrefix(dsn, "postgres://") || strings.HasPrefix(dsn, "postgresql://") {
 			// Use PostgreSQL
 			// Use PostgreSQL
 			common.SysLog("using PostgreSQL as database")
 			common.SysLog("using PostgreSQL as database")
 			common.UsingPostgreSQL = true
 			common.UsingPostgreSQL = true

relay/channel/adapter.go

@@ -13,7 +13,7 @@ type Adaptor interface {
 	Init(info *relaycommon.RelayInfo)
 	Init(info *relaycommon.RelayInfo)
 	GetRequestURL(info *relaycommon.RelayInfo) (string, error)
 	GetRequestURL(info *relaycommon.RelayInfo) (string, error)
 	SetupRequestHeader(c *gin.Context, req *http.Header, info *relaycommon.RelayInfo) error
 	SetupRequestHeader(c *gin.Context, req *http.Header, info *relaycommon.RelayInfo) error
-	ConvertRequest(c *gin.Context, info *relaycommon.RelayInfo, request *dto.GeneralOpenAIRequest) (any, error)
+	ConvertOpenAIRequest(c *gin.Context, info *relaycommon.RelayInfo, request *dto.GeneralOpenAIRequest) (any, error)
 	ConvertRerankRequest(c *gin.Context, relayMode int, request dto.RerankRequest) (any, error)
 	ConvertRerankRequest(c *gin.Context, relayMode int, request dto.RerankRequest) (any, error)
 	ConvertEmbeddingRequest(c *gin.Context, info *relaycommon.RelayInfo, request dto.EmbeddingRequest) (any, error)
 	ConvertEmbeddingRequest(c *gin.Context, info *relaycommon.RelayInfo, request dto.EmbeddingRequest) (any, error)
 	ConvertAudioRequest(c *gin.Context, info *relaycommon.RelayInfo, request dto.AudioRequest) (io.Reader, error)
 	ConvertAudioRequest(c *gin.Context, info *relaycommon.RelayInfo, request dto.AudioRequest) (io.Reader, error)
@@ -22,6 +22,7 @@ type Adaptor interface {
 	DoResponse(c *gin.Context, resp *http.Response, info *relaycommon.RelayInfo) (usage any, err *dto.OpenAIErrorWithStatusCode)
 	DoResponse(c *gin.Context, resp *http.Response, info *relaycommon.RelayInfo) (usage any, err *dto.OpenAIErrorWithStatusCode)
 	GetModelList() []string
 	GetModelList() []string
 	GetChannelName() string
 	GetChannelName() string
+	ConvertClaudeRequest(c *gin.Context, info *relaycommon.RelayInfo, request *dto.ClaudeRequest) (any, error)
 }
 }
 
 
 type TaskAdaptor interface {
 type TaskAdaptor interface {

relay/channel/ali/adaptor.go

@@ -16,6 +16,12 @@ import (
 type Adaptor struct {
 type Adaptor struct {
 }
 }
 
 
+func (a *Adaptor) ConvertClaudeRequest(*gin.Context, *relaycommon.RelayInfo, *dto.ClaudeRequest) (any, error) {
+	//TODO implement me
+	panic("implement me")
+	return nil, nil
+}
+
 func (a *Adaptor) Init(info *relaycommon.RelayInfo) {
 func (a *Adaptor) Init(info *relaycommon.RelayInfo) {
 }
 }
 
 
@@ -44,7 +50,7 @@ func (a *Adaptor) SetupRequestHeader(c *gin.Context, req *http.Header, info *rel
 	return nil
 	return nil
 }
 }
 
 
-func (a *Adaptor) ConvertRequest(c *gin.Context, info *relaycommon.RelayInfo, request *dto.GeneralOpenAIRequest) (any, error) {
+func (a *Adaptor) ConvertOpenAIRequest(c *gin.Context, info *relaycommon.RelayInfo, request *dto.GeneralOpenAIRequest) (any, error) {
 	if request == nil {
 	if request == nil {
 		return nil, errors.New("request is nil")
 		return nil, errors.New("request is nil")
 	}
 	}
@@ -87,7 +93,7 @@ func (a *Adaptor) DoResponse(c *gin.Context, resp *http.Response, info *relaycom
 		if info.IsStream {
 		if info.IsStream {
 			err, usage = openai.OaiStreamHandler(c, resp, info)
 			err, usage = openai.OaiStreamHandler(c, resp, info)
 		} else {
 		} else {
-			err, usage = openai.OpenaiHandler(c, resp, info.PromptTokens, info.UpstreamModelName)
+			err, usage = openai.OpenaiHandler(c, resp, info)
 		}
 		}
 	}
 	}
 	return
 	return

relay/channel/ali/image.go

@@ -26,7 +26,7 @@ func oaiImage2Ali(request dto.ImageRequest) *AliImageRequest {
 	return &imageRequest
 	return &imageRequest
 }
 }
 
 
-func updateTask(info *relaycommon.RelayInfo, taskID string, key string) (*AliResponse, error, []byte) {
+func updateTask(info *relaycommon.RelayInfo, taskID string) (*AliResponse, error, []byte) {
 	url := fmt.Sprintf("%s/api/v1/tasks/%s", info.BaseUrl, taskID)
 	url := fmt.Sprintf("%s/api/v1/tasks/%s", info.BaseUrl, taskID)
 
 
 	var aliResponse AliResponse
 	var aliResponse AliResponse
@@ -36,7 +36,7 @@ func updateTask(info *relaycommon.RelayInfo, taskID string, key string) (*AliRes
 		return &aliResponse, err, nil
 		return &aliResponse, err, nil
 	}
 	}
 
 
-	req.Header.Set("Authorization", "Bearer "+key)
+	req.Header.Set("Authorization", "Bearer "+info.ApiKey)
 
 
 	client := &http.Client{}
 	client := &http.Client{}
 	resp, err := client.Do(req)
 	resp, err := client.Do(req)
@@ -58,7 +58,7 @@ func updateTask(info *relaycommon.RelayInfo, taskID string, key string) (*AliRes
 	return &response, nil, responseBody
 	return &response, nil, responseBody
 }
 }
 
 
-func asyncTaskWait(info *relaycommon.RelayInfo, taskID string, key string) (*AliResponse, []byte, error) {
+func asyncTaskWait(info *relaycommon.RelayInfo, taskID string) (*AliResponse, []byte, error) {
 	waitSeconds := 3
 	waitSeconds := 3
 	step := 0
 	step := 0
 	maxStep := 20
 	maxStep := 20
@@ -68,7 +68,7 @@ func asyncTaskWait(info *relaycommon.RelayInfo, taskID string, key string) (*Ali
 
 
 	for {
 	for {
 		step++
 		step++
-		rsp, err, body := updateTask(info, taskID, key)
+		rsp, err, body := updateTask(info, taskID)
 		responseBody = body
 		responseBody = body
 		if err != nil {
 		if err != nil {
 			return &taskResponse, responseBody, err
 			return &taskResponse, responseBody, err
@@ -125,8 +125,6 @@ func responseAli2OpenAIImage(c *gin.Context, response *AliResponse, info *relayc
 }
 }
 
 
 func aliImageHandler(c *gin.Context, resp *http.Response, info *relaycommon.RelayInfo) (*dto.OpenAIErrorWithStatusCode, *dto.Usage) {
 func aliImageHandler(c *gin.Context, resp *http.Response, info *relaycommon.RelayInfo) (*dto.OpenAIErrorWithStatusCode, *dto.Usage) {
-	apiKey := c.Request.Header.Get("Authorization")
-	apiKey = strings.TrimPrefix(apiKey, "Bearer ")
 	responseFormat := c.GetString("response_format")
 	responseFormat := c.GetString("response_format")
 
 
 	var aliTaskResponse AliResponse
 	var aliTaskResponse AliResponse
@@ -148,7 +146,7 @@ func aliImageHandler(c *gin.Context, resp *http.Response, info *relaycommon.Rela
 		return service.OpenAIErrorWrapper(errors.New(aliTaskResponse.Message), "ali_async_task_failed", http.StatusInternalServerError), nil
 		return service.OpenAIErrorWrapper(errors.New(aliTaskResponse.Message), "ali_async_task_failed", http.StatusInternalServerError), nil
 	}
 	}
 
 
-	aliResponse, _, err := asyncTaskWait(info, aliTaskResponse.Output.TaskId, apiKey)
+	aliResponse, _, err := asyncTaskWait(info, aliTaskResponse.Output.TaskId)
 	if err != nil {
 	if err != nil {
 		return service.OpenAIErrorWrapper(err, "ali_async_task_wait_failed", http.StatusInternalServerError), nil
 		return service.OpenAIErrorWrapper(err, "ali_async_task_wait_failed", http.StatusInternalServerError), nil
 	}
 	}

relay/channel/api_request.go

@@ -7,6 +7,7 @@ import (
 	"github.com/gorilla/websocket"
 	"github.com/gorilla/websocket"
 	"io"
 	"io"
 	"net/http"
 	"net/http"
+	common2 "one-api/common"
 	"one-api/relay/common"
 	"one-api/relay/common"
 	"one-api/relay/constant"
 	"one-api/relay/constant"
 	"one-api/service"
 	"one-api/service"
@@ -31,6 +32,9 @@ func DoApiRequest(a Adaptor, c *gin.Context, info *common.RelayInfo, requestBody
 	if err != nil {
 	if err != nil {
 		return nil, fmt.Errorf("get request url failed: %w", err)
 		return nil, fmt.Errorf("get request url failed: %w", err)
 	}
 	}
+	if common2.DebugEnabled {
+		println("fullRequestURL:", fullRequestURL)
+	}
 	req, err := http.NewRequest(c.Request.Method, fullRequestURL, requestBody)
 	req, err := http.NewRequest(c.Request.Method, fullRequestURL, requestBody)
 	if err != nil {
 	if err != nil {
 		return nil, fmt.Errorf("new request failed: %w", err)
 		return nil, fmt.Errorf("new request failed: %w", err)

relay/channel/aws/adaptor.go

@@ -20,6 +20,10 @@ type Adaptor struct {
 	RequestMode int
 	RequestMode int
 }
 }
 
 
+func (a *Adaptor) ConvertClaudeRequest(c *gin.Context, info *relaycommon.RelayInfo, request *dto.ClaudeRequest) (any, error) {
+	return request, nil
+}
+
 func (a *Adaptor) ConvertAudioRequest(c *gin.Context, info *relaycommon.RelayInfo, request dto.AudioRequest) (io.Reader, error) {
 func (a *Adaptor) ConvertAudioRequest(c *gin.Context, info *relaycommon.RelayInfo, request dto.AudioRequest) (io.Reader, error) {
 	//TODO implement me
 	//TODO implement me
 	return nil, errors.New("not implemented")
 	return nil, errors.New("not implemented")
@@ -43,12 +47,12 @@ func (a *Adaptor) SetupRequestHeader(c *gin.Context, req *http.Header, info *rel
 	return nil
 	return nil
 }
 }
 
 
-func (a *Adaptor) ConvertRequest(c *gin.Context, info *relaycommon.RelayInfo, request *dto.GeneralOpenAIRequest) (any, error) {
+func (a *Adaptor) ConvertOpenAIRequest(c *gin.Context, info *relaycommon.RelayInfo, request *dto.GeneralOpenAIRequest) (any, error) {
 	if request == nil {
 	if request == nil {
 		return nil, errors.New("request is nil")
 		return nil, errors.New("request is nil")
 	}
 	}
 
 
-	var claudeReq *claude.ClaudeRequest
+	var claudeReq *dto.ClaudeRequest
 	var err error
 	var err error
 	claudeReq, err = claude.RequestOpenAI2ClaudeMessage(*request)
 	claudeReq, err = claude.RequestOpenAI2ClaudeMessage(*request)
 	if err != nil {
 	if err != nil {

relay/channel/aws/dto.go

 package aws
 package aws
 
 
 import (
 import (
-	"one-api/relay/channel/claude"
+	"one-api/dto"
 )
 )
 
 
 type AwsClaudeRequest struct {
 type AwsClaudeRequest struct {
 	// AnthropicVersion should be "bedrock-2023-05-31"
 	// AnthropicVersion should be "bedrock-2023-05-31"
-	AnthropicVersion string                 `json:"anthropic_version"`
-	System           string                 `json:"system,omitempty"`
-	Messages         []claude.ClaudeMessage `json:"messages"`
-	MaxTokens        uint                   `json:"max_tokens,omitempty"`
-	Temperature      *float64               `json:"temperature,omitempty"`
-	TopP             float64                `json:"top_p,omitempty"`
-	TopK             int                    `json:"top_k,omitempty"`
-	StopSequences    []string               `json:"stop_sequences,omitempty"`
-	Tools            any                    `json:"tools,omitempty"`
-	ToolChoice       any                    `json:"tool_choice,omitempty"`
-	Thinking         *claude.Thinking       `json:"thinking,omitempty"`
+	AnthropicVersion string              `json:"anthropic_version"`
+	System           any                 `json:"system,omitempty"`
+	Messages         []dto.ClaudeMessage `json:"messages"`
+	MaxTokens        uint                `json:"max_tokens,omitempty"`
+	Temperature      *float64            `json:"temperature,omitempty"`
+	TopP             float64             `json:"top_p,omitempty"`
+	TopK             int                 `json:"top_k,omitempty"`
+	StopSequences    []string            `json:"stop_sequences,omitempty"`
+	Tools            any                 `json:"tools,omitempty"`
+	ToolChoice       any                 `json:"tool_choice,omitempty"`
+	Thinking         *dto.Thinking       `json:"thinking,omitempty"`
 }
 }
 
 
-func copyRequest(req *claude.ClaudeRequest) *AwsClaudeRequest {
+func copyRequest(req *dto.ClaudeRequest) *AwsClaudeRequest {
 	return &AwsClaudeRequest{
 	return &AwsClaudeRequest{
 		AnthropicVersion: "bedrock-2023-05-31",
 		AnthropicVersion: "bedrock-2023-05-31",
 		System:           req.System,
 		System:           req.System,

relay/channel/aws/relay-aws.go

@@ -9,7 +9,7 @@ import (
 	"io"
 	"io"
 	"net/http"
 	"net/http"
 	"one-api/common"
 	"one-api/common"
-	relaymodel "one-api/dto"
+	"one-api/dto"
 	"one-api/relay/channel/claude"
 	"one-api/relay/channel/claude"
 	relaycommon "one-api/relay/common"
 	relaycommon "one-api/relay/common"
 	"one-api/relay/helper"
 	"one-api/relay/helper"
@@ -39,10 +39,10 @@ func newAwsClient(c *gin.Context, info *relaycommon.RelayInfo) (*bedrockruntime.
 	return client, nil
 	return client, nil
 }
 }
 
 
-func wrapErr(err error) *relaymodel.OpenAIErrorWithStatusCode {
-	return &relaymodel.OpenAIErrorWithStatusCode{
+func wrapErr(err error) *dto.OpenAIErrorWithStatusCode {
+	return &dto.OpenAIErrorWithStatusCode{
 		StatusCode: http.StatusInternalServerError,
 		StatusCode: http.StatusInternalServerError,
-		Error: relaymodel.OpenAIError{
+		Error: dto.OpenAIError{
 			Message: fmt.Sprintf("%s", err.Error()),
 			Message: fmt.Sprintf("%s", err.Error()),
 		},
 		},
 	}
 	}
@@ -56,7 +56,7 @@ func awsModelID(requestModel string) (string, error) {
 	return requestModel, nil
 	return requestModel, nil
 }
 }
 
 
-func awsHandler(c *gin.Context, info *relaycommon.RelayInfo, requestMode int) (*relaymodel.OpenAIErrorWithStatusCode, *relaymodel.Usage) {
+func awsHandler(c *gin.Context, info *relaycommon.RelayInfo, requestMode int) (*dto.OpenAIErrorWithStatusCode, *dto.Usage) {
 	awsCli, err := newAwsClient(c, info)
 	awsCli, err := newAwsClient(c, info)
 	if err != nil {
 	if err != nil {
 		return wrapErr(errors.Wrap(err, "newAwsClient")), nil
 		return wrapErr(errors.Wrap(err, "newAwsClient")), nil
@@ -77,7 +77,7 @@ func awsHandler(c *gin.Context, info *relaycommon.RelayInfo, requestMode int) (*
 	if !ok {
 	if !ok {
 		return wrapErr(errors.New("request not found")), nil
 		return wrapErr(errors.New("request not found")), nil
 	}
 	}
-	claudeReq := claudeReq_.(*claude.ClaudeRequest)
+	claudeReq := claudeReq_.(*dto.ClaudeRequest)
 	awsClaudeReq := copyRequest(claudeReq)
 	awsClaudeReq := copyRequest(claudeReq)
 	awsReq.Body, err = json.Marshal(awsClaudeReq)
 	awsReq.Body, err = json.Marshal(awsClaudeReq)
 	if err != nil {
 	if err != nil {
@@ -89,14 +89,14 @@ func awsHandler(c *gin.Context, info *relaycommon.RelayInfo, requestMode int) (*
 		return wrapErr(errors.Wrap(err, "InvokeModel")), nil
 		return wrapErr(errors.Wrap(err, "InvokeModel")), nil
 	}
 	}
 
 
-	claudeResponse := new(claude.ClaudeResponse)
+	claudeResponse := new(dto.ClaudeResponse)
 	err = json.Unmarshal(awsResp.Body, claudeResponse)
 	err = json.Unmarshal(awsResp.Body, claudeResponse)
 	if err != nil {
 	if err != nil {
 		return wrapErr(errors.Wrap(err, "unmarshal response")), nil
 		return wrapErr(errors.Wrap(err, "unmarshal response")), nil
 	}
 	}
 
 
 	openaiResp := claude.ResponseClaude2OpenAI(requestMode, claudeResponse)
 	openaiResp := claude.ResponseClaude2OpenAI(requestMode, claudeResponse)
-	usage := relaymodel.Usage{
+	usage := dto.Usage{
 		PromptTokens:     claudeResponse.Usage.InputTokens,
 		PromptTokens:     claudeResponse.Usage.InputTokens,
 		CompletionTokens: claudeResponse.Usage.OutputTokens,
 		CompletionTokens: claudeResponse.Usage.OutputTokens,
 		TotalTokens:      claudeResponse.Usage.InputTokens + claudeResponse.Usage.OutputTokens,
 		TotalTokens:      claudeResponse.Usage.InputTokens + claudeResponse.Usage.OutputTokens,
@@ -107,7 +107,7 @@ func awsHandler(c *gin.Context, info *relaycommon.RelayInfo, requestMode int) (*
 	return nil, &usage
 	return nil, &usage
 }
 }
 
 
-func awsStreamHandler(c *gin.Context, resp *http.Response, info *relaycommon.RelayInfo, requestMode int) (*relaymodel.OpenAIErrorWithStatusCode, *relaymodel.Usage) {
+func awsStreamHandler(c *gin.Context, resp *http.Response, info *relaycommon.RelayInfo, requestMode int) (*dto.OpenAIErrorWithStatusCode, *dto.Usage) {
 	awsCli, err := newAwsClient(c, info)
 	awsCli, err := newAwsClient(c, info)
 	if err != nil {
 	if err != nil {
 		return wrapErr(errors.Wrap(err, "newAwsClient")), nil
 		return wrapErr(errors.Wrap(err, "newAwsClient")), nil
@@ -128,7 +128,7 @@ func awsStreamHandler(c *gin.Context, resp *http.Response, info *relaycommon.Rel
 	if !ok {
 	if !ok {
 		return wrapErr(errors.New("request not found")), nil
 		return wrapErr(errors.New("request not found")), nil
 	}
 	}
-	claudeReq := claudeReq_.(*claude.ClaudeRequest)
+	claudeReq := claudeReq_.(*dto.ClaudeRequest)
 
 
 	awsClaudeReq := copyRequest(claudeReq)
 	awsClaudeReq := copyRequest(claudeReq)
 	awsReq.Body, err = json.Marshal(awsClaudeReq)
 	awsReq.Body, err = json.Marshal(awsClaudeReq)
@@ -144,11 +144,14 @@ func awsStreamHandler(c *gin.Context, resp *http.Response, info *relaycommon.Rel
 	defer stream.Close()
 	defer stream.Close()
 
 
 	c.Writer.Header().Set("Content-Type", "text/event-stream")
 	c.Writer.Header().Set("Content-Type", "text/event-stream")
-	var usage relaymodel.Usage
-	var id string
-	var model string
+	claudeInfo := &claude.ClaudeResponseInfo{
+		ResponseId:   fmt.Sprintf("chatcmpl-%s", common.GetUUID()),
+		Created:      common.GetTimestamp(),
+		Model:        info.UpstreamModelName,
+		ResponseText: strings.Builder{},
+		Usage:        &dto.Usage{},
+	}
 	isFirst := true
 	isFirst := true
-	createdTime := common.GetTimestamp()
 	c.Stream(func(w io.Writer) bool {
 	c.Stream(func(w io.Writer) bool {
 		event, ok := <-stream.Events()
 		event, ok := <-stream.Events()
 		if !ok {
 		if !ok {
@@ -161,33 +164,19 @@ func awsStreamHandler(c *gin.Context, resp *http.Response, info *relaycommon.Rel
 				isFirst = false
 				isFirst = false
 				info.FirstResponseTime = time.Now()
 				info.FirstResponseTime = time.Now()
 			}
 			}
-			claudeResp := new(claude.ClaudeResponse)
-			err := json.NewDecoder(bytes.NewReader(v.Value.Bytes)).Decode(claudeResp)
+			claudeResponse := new(dto.ClaudeResponse)
+			err := json.NewDecoder(bytes.NewReader(v.Value.Bytes)).Decode(claudeResponse)
 			if err != nil {
 			if err != nil {
 				common.SysError("error unmarshalling stream response: " + err.Error())
 				common.SysError("error unmarshalling stream response: " + err.Error())
 				return false
 				return false
 			}
 			}
 
 
-			response, claudeUsage := claude.StreamResponseClaude2OpenAI(requestMode, claudeResp)
-			if claudeUsage != nil {
-				usage.PromptTokens += claudeUsage.InputTokens
-				usage.CompletionTokens += claudeUsage.OutputTokens
-			}
+			response := claude.StreamResponseClaude2OpenAI(requestMode, claudeResponse)
 
 
-			if response == nil {
+			if !claude.FormatClaudeResponseInfo(RequestModeMessage, claudeResponse, response, claudeInfo) {
 				return true
 				return true
 			}
 			}
 
 
-			if response.Id != "" {
-				id = response.Id
-			}
-			if response.Model != "" {
-				model = response.Model
-			}
-			response.Created = createdTime
-			response.Id = id
-			response.Model = model
-
 			jsonStr, err := json.Marshal(response)
 			jsonStr, err := json.Marshal(response)
 			if err != nil {
 			if err != nil {
 				common.SysError("error marshalling stream response: " + err.Error())
 				common.SysError("error marshalling stream response: " + err.Error())
@@ -203,8 +192,16 @@ func awsStreamHandler(c *gin.Context, resp *http.Response, info *relaycommon.Rel
 			return false
 			return false
 		}
 		}
 	})
 	})
+
+	if claudeInfo.Usage.PromptTokens == 0 {
+		//上游出错
+	}
+	if claudeInfo.Usage.CompletionTokens == 0 {
+		claudeInfo.Usage, _ = service.ResponseText2Usage(claudeInfo.ResponseText.String(), info.UpstreamModelName, claudeInfo.Usage.PromptTokens)
+	}
+
 	if info.ShouldIncludeUsage {
 	if info.ShouldIncludeUsage {
-		response := helper.GenerateFinalUsageResponse(id, createdTime, info.UpstreamModelName, usage)
+		response := helper.GenerateFinalUsageResponse(claudeInfo.ResponseId, claudeInfo.Created, info.UpstreamModelName, *claudeInfo.Usage)
 		err := helper.ObjectData(c, response)
 		err := helper.ObjectData(c, response)
 		if err != nil {
 		if err != nil {
 			common.SysError("send final response failed: " + err.Error())
 			common.SysError("send final response failed: " + err.Error())
@@ -217,5 +214,5 @@ func awsStreamHandler(c *gin.Context, resp *http.Response, info *relaycommon.Rel
 			return service.OpenAIErrorWrapperLocal(err, "close_response_body_failed", http.StatusInternalServerError), nil
 			return service.OpenAIErrorWrapperLocal(err, "close_response_body_failed", http.StatusInternalServerError), nil
 		}
 		}
 	}
 	}
-	return nil, &usage
+	return nil, claudeInfo.Usage
 }
 }

relay/channel/baidu/adaptor.go

@@ -16,6 +16,12 @@ import (
 type Adaptor struct {
 type Adaptor struct {
 }
 }
 
 
+func (a *Adaptor) ConvertClaudeRequest(*gin.Context, *relaycommon.RelayInfo, *dto.ClaudeRequest) (any, error) {
+	//TODO implement me
+	panic("implement me")
+	return nil, nil
+}
+
 func (a *Adaptor) ConvertAudioRequest(c *gin.Context, info *relaycommon.RelayInfo, request dto.AudioRequest) (io.Reader, error) {
 func (a *Adaptor) ConvertAudioRequest(c *gin.Context, info *relaycommon.RelayInfo, request dto.AudioRequest) (io.Reader, error) {
 	//TODO implement me
 	//TODO implement me
 	return nil, errors.New("not implemented")
 	return nil, errors.New("not implemented")
@@ -104,7 +110,7 @@ func (a *Adaptor) SetupRequestHeader(c *gin.Context, req *http.Header, info *rel
 	return nil
 	return nil
 }
 }
 
 
-func (a *Adaptor) ConvertRequest(c *gin.Context, info *relaycommon.RelayInfo, request *dto.GeneralOpenAIRequest) (any, error) {
+func (a *Adaptor) ConvertOpenAIRequest(c *gin.Context, info *relaycommon.RelayInfo, request *dto.GeneralOpenAIRequest) (any, error) {
 	if request == nil {
 	if request == nil {
 		return nil, errors.New("request is nil")
 		return nil, errors.New("request is nil")
 	}
 	}

relay/channel/baidu_v2/adaptor.go

@@ -15,6 +15,12 @@ import (
 type Adaptor struct {
 type Adaptor struct {
 }
 }
 
 
+func (a *Adaptor) ConvertClaudeRequest(*gin.Context, *relaycommon.RelayInfo, *dto.ClaudeRequest) (any, error) {
+	//TODO implement me
+	panic("implement me")
+	return nil, nil
+}
+
 func (a *Adaptor) ConvertAudioRequest(c *gin.Context, info *relaycommon.RelayInfo, request dto.AudioRequest) (io.Reader, error) {
 func (a *Adaptor) ConvertAudioRequest(c *gin.Context, info *relaycommon.RelayInfo, request dto.AudioRequest) (io.Reader, error) {
 	//TODO implement me
 	//TODO implement me
 	return nil, errors.New("not implemented")
 	return nil, errors.New("not implemented")
@@ -38,7 +44,7 @@ func (a *Adaptor) SetupRequestHeader(c *gin.Context, req *http.Header, info *rel
 	return nil
 	return nil
 }
 }
 
 
-func (a *Adaptor) ConvertRequest(c *gin.Context, info *relaycommon.RelayInfo, request *dto.GeneralOpenAIRequest) (any, error) {
+func (a *Adaptor) ConvertOpenAIRequest(c *gin.Context, info *relaycommon.RelayInfo, request *dto.GeneralOpenAIRequest) (any, error) {
 	if request == nil {
 	if request == nil {
 		return nil, errors.New("request is nil")
 		return nil, errors.New("request is nil")
 	}
 	}
@@ -62,7 +68,7 @@ func (a *Adaptor) DoResponse(c *gin.Context, resp *http.Response, info *relaycom
 	if info.IsStream {
 	if info.IsStream {
 		err, usage = openai.OaiStreamHandler(c, resp, info)
 		err, usage = openai.OaiStreamHandler(c, resp, info)
 	} else {
 	} else {
-		err, usage = openai.OpenaiHandler(c, resp, info.PromptTokens, info.UpstreamModelName)
+		err, usage = openai.OpenaiHandler(c, resp, info)
 	}
 	}
 	return
 	return
 }
 }

relay/channel/claude/adaptor.go

@@ -22,6 +22,10 @@ type Adaptor struct {
 	RequestMode int
 	RequestMode int
 }
 }
 
 
+func (a *Adaptor) ConvertClaudeRequest(c *gin.Context, info *relaycommon.RelayInfo, request *dto.ClaudeRequest) (any, error) {
+	return request, nil
+}
+
 func (a *Adaptor) ConvertAudioRequest(c *gin.Context, info *relaycommon.RelayInfo, request dto.AudioRequest) (io.Reader, error) {
 func (a *Adaptor) ConvertAudioRequest(c *gin.Context, info *relaycommon.RelayInfo, request dto.AudioRequest) (io.Reader, error) {
 	//TODO implement me
 	//TODO implement me
 	return nil, errors.New("not implemented")
 	return nil, errors.New("not implemented")
@@ -60,7 +64,7 @@ func (a *Adaptor) SetupRequestHeader(c *gin.Context, req *http.Header, info *rel
 	return nil
 	return nil
 }
 }
 
 
-func (a *Adaptor) ConvertRequest(c *gin.Context, info *relaycommon.RelayInfo, request *dto.GeneralOpenAIRequest) (any, error) {
+func (a *Adaptor) ConvertOpenAIRequest(c *gin.Context, info *relaycommon.RelayInfo, request *dto.GeneralOpenAIRequest) (any, error) {
 	if request == nil {
 	if request == nil {
 		return nil, errors.New("request is nil")
 		return nil, errors.New("request is nil")
 	}
 	}

relay/channel/claude/dto.go

 package claude
 package claude
 
 
-type ClaudeMetadata struct {
-	UserId string `json:"user_id"`
-}
-
-type ClaudeMediaMessage struct {
-	Type        string               `json:"type"`
-	Text        string               `json:"text,omitempty"`
-	Source      *ClaudeMessageSource `json:"source,omitempty"`
-	Usage       *ClaudeUsage         `json:"usage,omitempty"`
-	StopReason  *string              `json:"stop_reason,omitempty"`
-	PartialJson string               `json:"partial_json,omitempty"`
-	Thinking    string               `json:"thinking,omitempty"`
-	Signature   string               `json:"signature,omitempty"`
-	Delta       string               `json:"delta,omitempty"`
-	// tool_calls
-	Id        string `json:"id,omitempty"`
-	Name      string `json:"name,omitempty"`
-	Input     any    `json:"input,omitempty"`
-	Content   string `json:"content,omitempty"`
-	ToolUseId string `json:"tool_use_id,omitempty"`
-}
-
-type ClaudeMessageSource struct {
-	Type      string `json:"type"`
-	MediaType string `json:"media_type"`
-	Data      string `json:"data"`
-}
-
-type ClaudeMessage struct {
-	Role    string `json:"role"`
-	Content any    `json:"content"`
-}
-
-type Tool struct {
-	Name        string                 `json:"name"`
-	Description string                 `json:"description,omitempty"`
-	InputSchema map[string]interface{} `json:"input_schema"`
-}
-
-type InputSchema struct {
-	Type       string `json:"type"`
-	Properties any    `json:"properties,omitempty"`
-	Required   any    `json:"required,omitempty"`
-}
-
-type ClaudeRequest struct {
-	Model             string          `json:"model"`
-	Prompt            string          `json:"prompt,omitempty"`
-	System            string          `json:"system,omitempty"`
-	Messages          []ClaudeMessage `json:"messages,omitempty"`
-	MaxTokens         uint            `json:"max_tokens,omitempty"`
-	MaxTokensToSample uint            `json:"max_tokens_to_sample,omitempty"`
-	StopSequences     []string        `json:"stop_sequences,omitempty"`
-	Temperature       *float64        `json:"temperature,omitempty"`
-	TopP              float64         `json:"top_p,omitempty"`
-	TopK              int             `json:"top_k,omitempty"`
-	//ClaudeMetadata    `json:"metadata,omitempty"`
-	Stream     bool      `json:"stream,omitempty"`
-	Tools      any       `json:"tools,omitempty"`
-	ToolChoice any       `json:"tool_choice,omitempty"`
-	Thinking   *Thinking `json:"thinking,omitempty"`
-}
-
-type Thinking struct {
-	Type         string `json:"type"`
-	BudgetTokens int    `json:"budget_tokens"`
-}
-
-type ClaudeError struct {
-	Type    string `json:"type"`
-	Message string `json:"message"`
-}
-
-type ClaudeResponse struct {
-	Id           string               `json:"id"`
-	Type         string               `json:"type"`
-	Content      []ClaudeMediaMessage `json:"content"`
-	Completion   string               `json:"completion"`
-	StopReason   string               `json:"stop_reason"`
-	Model        string               `json:"model"`
-	Error        ClaudeError          `json:"error"`
-	Usage        ClaudeUsage          `json:"usage"`
-	Index        int                  `json:"index"` // stream only
-	ContentBlock *ClaudeMediaMessage  `json:"content_block"`
-	Delta        *ClaudeMediaMessage  `json:"delta"`   // stream only
-	Message      *ClaudeResponse      `json:"message"` // stream only: message_start
-}
-
-type ClaudeUsage struct {
-	InputTokens  int `json:"input_tokens"`
-	OutputTokens int `json:"output_tokens"`
-}
+//
+//type ClaudeMetadata struct {
+//	UserId string `json:"user_id"`
+//}
+//
+//type ClaudeMediaMessage struct {
+//	Type        string               `json:"type"`
+//	Text        string               `json:"text,omitempty"`
+//	Source      *ClaudeMessageSource `json:"source,omitempty"`
+//	Usage       *ClaudeUsage         `json:"usage,omitempty"`
+//	StopReason  *string              `json:"stop_reason,omitempty"`
+//	PartialJson string               `json:"partial_json,omitempty"`
+//	Thinking    string               `json:"thinking,omitempty"`
+//	Signature   string               `json:"signature,omitempty"`
+//	Delta       string               `json:"delta,omitempty"`
+//	// tool_calls
+//	Id        string `json:"id,omitempty"`
+//	Name      string `json:"name,omitempty"`
+//	Input     any    `json:"input,omitempty"`
+//	Content   string `json:"content,omitempty"`
+//	ToolUseId string `json:"tool_use_id,omitempty"`
+//}
+//
+//type ClaudeMessageSource struct {
+//	Type      string `json:"type"`
+//	MediaType string `json:"media_type"`
+//	Data      string `json:"data"`
+//}
+//
+//type ClaudeMessage struct {
+//	Role    string `json:"role"`
+//	Content any    `json:"content"`
+//}
+//
+//type Tool struct {
+//	Name        string                 `json:"name"`
+//	Description string                 `json:"description,omitempty"`
+//	InputSchema map[string]interface{} `json:"input_schema"`
+//}
+//
+//type InputSchema struct {
+//	Type       string `json:"type"`
+//	Properties any    `json:"properties,omitempty"`
+//	Required   any    `json:"required,omitempty"`
+//}
+//
+//type ClaudeRequest struct {
+//	Model             string          `json:"model"`
+//	Prompt            string          `json:"prompt,omitempty"`
+//	System            string          `json:"system,omitempty"`
+//	Messages          []ClaudeMessage `json:"messages,omitempty"`
+//	MaxTokens         uint            `json:"max_tokens,omitempty"`
+//	MaxTokensToSample uint            `json:"max_tokens_to_sample,omitempty"`
+//	StopSequences     []string        `json:"stop_sequences,omitempty"`
+//	Temperature       *float64        `json:"temperature,omitempty"`
+//	TopP              float64         `json:"top_p,omitempty"`
+//	TopK              int             `json:"top_k,omitempty"`
+//	//ClaudeMetadata    `json:"metadata,omitempty"`
+//	Stream     bool      `json:"stream,omitempty"`
+//	Tools      any       `json:"tools,omitempty"`
+//	ToolChoice any       `json:"tool_choice,omitempty"`
+//	Thinking   *Thinking `json:"thinking,omitempty"`
+//}
+//
+//type Thinking struct {
+//	Type         string `json:"type"`
+//	BudgetTokens int    `json:"budget_tokens"`
+//}
+//
+//type ClaudeError struct {
+//	Type    string `json:"type"`
+//	Message string `json:"message"`
+//}
+//
+//type ClaudeResponse struct {
+//	Id           string               `json:"id"`
+//	Type         string               `json:"type"`
+//	Content      []ClaudeMediaMessage `json:"content"`
+//	Completion   string               `json:"completion"`
+//	StopReason   string               `json:"stop_reason"`
+//	Model        string               `json:"model"`
+//	Error        ClaudeError          `json:"error"`
+//	Usage        ClaudeUsage          `json:"usage"`
+//	Index        int                  `json:"index"` // stream only
+//	ContentBlock *ClaudeMediaMessage  `json:"content_block"`
+//	Delta        *ClaudeMediaMessage  `json:"delta"`   // stream only
+//	Message      *ClaudeResponse      `json:"message"` // stream only: message_start
+//}
+//
+//type ClaudeUsage struct {
+//	InputTokens  int `json:"input_tokens"`
+//	OutputTokens int `json:"output_tokens"`
+//}

relay/channel/cloudflare/adaptor.go

@@ -17,6 +17,12 @@ import (
 type Adaptor struct {
 type Adaptor struct {
 }
 }
 
 
+func (a *Adaptor) ConvertClaudeRequest(*gin.Context, *relaycommon.RelayInfo, *dto.ClaudeRequest) (any, error) {
+	//TODO implement me
+	panic("implement me")
+	return nil, nil
+}
+
 func (a *Adaptor) Init(info *relaycommon.RelayInfo) {
 func (a *Adaptor) Init(info *relaycommon.RelayInfo) {
 }
 }
 
 
@@ -37,7 +43,7 @@ func (a *Adaptor) SetupRequestHeader(c *gin.Context, req *http.Header, info *rel
 	return nil
 	return nil
 }
 }
 
 
-func (a *Adaptor) ConvertRequest(c *gin.Context, info *relaycommon.RelayInfo, request *dto.GeneralOpenAIRequest) (any, error) {
+func (a *Adaptor) ConvertOpenAIRequest(c *gin.Context, info *relaycommon.RelayInfo, request *dto.GeneralOpenAIRequest) (any, error) {
 	if request == nil {
 	if request == nil {
 		return nil, errors.New("request is nil")
 		return nil, errors.New("request is nil")
 	}
 	}

relay/channel/cohere/adaptor.go

@@ -15,6 +15,12 @@ import (
 type Adaptor struct {
 type Adaptor struct {
 }
 }
 
 
+func (a *Adaptor) ConvertClaudeRequest(*gin.Context, *relaycommon.RelayInfo, *dto.ClaudeRequest) (any, error) {
+	//TODO implement me
+	panic("implement me")
+	return nil, nil
+}
+
 func (a *Adaptor) ConvertAudioRequest(c *gin.Context, info *relaycommon.RelayInfo, request dto.AudioRequest) (io.Reader, error) {
 func (a *Adaptor) ConvertAudioRequest(c *gin.Context, info *relaycommon.RelayInfo, request dto.AudioRequest) (io.Reader, error) {
 	//TODO implement me
 	//TODO implement me
 	return nil, errors.New("not implemented")
 	return nil, errors.New("not implemented")
@@ -42,7 +48,7 @@ func (a *Adaptor) SetupRequestHeader(c *gin.Context, req *http.Header, info *rel
 	return nil
 	return nil
 }
 }
 
 
-func (a *Adaptor) ConvertRequest(c *gin.Context, info *relaycommon.RelayInfo, request *dto.GeneralOpenAIRequest) (any, error) {
+func (a *Adaptor) ConvertOpenAIRequest(c *gin.Context, info *relaycommon.RelayInfo, request *dto.GeneralOpenAIRequest) (any, error) {
 	return requestOpenAI2Cohere(*request), nil
 	return requestOpenAI2Cohere(*request), nil
 }
 }
 
 
@@ -59,7 +65,6 @@ func (a *Adaptor) ConvertEmbeddingRequest(c *gin.Context, info *relaycommon.Rela
 	return nil, errors.New("not implemented")
 	return nil, errors.New("not implemented")
 }
 }
 
 
-
 func (a *Adaptor) DoResponse(c *gin.Context, resp *http.Response, info *relaycommon.RelayInfo) (usage any, err *dto.OpenAIErrorWithStatusCode) {
 func (a *Adaptor) DoResponse(c *gin.Context, resp *http.Response, info *relaycommon.RelayInfo) (usage any, err *dto.OpenAIErrorWithStatusCode) {
 	if info.RelayMode == constant.RelayModeRerank {
 	if info.RelayMode == constant.RelayModeRerank {
 		err, usage = cohereRerankHandler(c, resp, info)
 		err, usage = cohereRerankHandler(c, resp, info)

relay/channel/deepseek/adaptor.go

@@ -16,6 +16,12 @@ import (
 type Adaptor struct {
 type Adaptor struct {
 }
 }
 
 
+func (a *Adaptor) ConvertClaudeRequest(*gin.Context, *relaycommon.RelayInfo, *dto.ClaudeRequest) (any, error) {
+	//TODO implement me
+	panic("implement me")
+	return nil, nil
+}
+
 func (a *Adaptor) ConvertAudioRequest(c *gin.Context, info *relaycommon.RelayInfo, request dto.AudioRequest) (io.Reader, error) {
 func (a *Adaptor) ConvertAudioRequest(c *gin.Context, info *relaycommon.RelayInfo, request dto.AudioRequest) (io.Reader, error) {
 	//TODO implement me
 	//TODO implement me
 	return nil, errors.New("not implemented")
 	return nil, errors.New("not implemented")
@@ -44,7 +50,7 @@ func (a *Adaptor) SetupRequestHeader(c *gin.Context, req *http.Header, info *rel
 	return nil
 	return nil
 }
 }
 
 
-func (a *Adaptor) ConvertRequest(c *gin.Context, info *relaycommon.RelayInfo, request *dto.GeneralOpenAIRequest) (any, error) {
+func (a *Adaptor) ConvertOpenAIRequest(c *gin.Context, info *relaycommon.RelayInfo, request *dto.GeneralOpenAIRequest) (any, error) {
 	if request == nil {
 	if request == nil {
 		return nil, errors.New("request is nil")
 		return nil, errors.New("request is nil")
 	}
 	}
@@ -68,7 +74,7 @@ func (a *Adaptor) DoResponse(c *gin.Context, resp *http.Response, info *relaycom
 	if info.IsStream {
 	if info.IsStream {
 		err, usage = openai.OaiStreamHandler(c, resp, info)
 		err, usage = openai.OaiStreamHandler(c, resp, info)
 	} else {
 	} else {
-		err, usage = openai.OpenaiHandler(c, resp, info.PromptTokens, info.UpstreamModelName)
+		err, usage = openai.OpenaiHandler(c, resp, info)
 	}
 	}
 	return
 	return
 }
 }

relay/channel/dify/adaptor.go

@@ -9,7 +9,6 @@ import (
 	"one-api/dto"
 	"one-api/dto"
 	"one-api/relay/channel"
 	"one-api/relay/channel"
 	relaycommon "one-api/relay/common"
 	relaycommon "one-api/relay/common"
-	"strings"
 )
 )
 
 
 const (
 const (
@@ -23,6 +22,12 @@ type Adaptor struct {
 	BotType int
 	BotType int
 }
 }
 
 
+func (a *Adaptor) ConvertClaudeRequest(*gin.Context, *relaycommon.RelayInfo, *dto.ClaudeRequest) (any, error) {
+	//TODO implement me
+	panic("implement me")
+	return nil, nil
+}
+
 func (a *Adaptor) ConvertAudioRequest(c *gin.Context, info *relaycommon.RelayInfo, request dto.AudioRequest) (io.Reader, error) {
 func (a *Adaptor) ConvertAudioRequest(c *gin.Context, info *relaycommon.RelayInfo, request dto.AudioRequest) (io.Reader, error) {
 	//TODO implement me
 	//TODO implement me
 	return nil, errors.New("not implemented")
 	return nil, errors.New("not implemented")
@@ -34,15 +39,16 @@ func (a *Adaptor) ConvertImageRequest(c *gin.Context, info *relaycommon.RelayInf
 }
 }
 
 
 func (a *Adaptor) Init(info *relaycommon.RelayInfo) {
 func (a *Adaptor) Init(info *relaycommon.RelayInfo) {
-	if strings.HasPrefix(info.UpstreamModelName, "agent") {
-		a.BotType = BotTypeAgent
-	} else if strings.HasPrefix(info.UpstreamModelName, "workflow") {
-		a.BotType = BotTypeWorkFlow
-	} else if strings.HasPrefix(info.UpstreamModelName, "chat") {
-		a.BotType = BotTypeCompletion
-	} else {
-		a.BotType = BotTypeChatFlow
-	}
+	//if strings.HasPrefix(info.UpstreamModelName, "agent") {
+	//	a.BotType = BotTypeAgent
+	//} else if strings.HasPrefix(info.UpstreamModelName, "workflow") {
+	//	a.BotType = BotTypeWorkFlow
+	//} else if strings.HasPrefix(info.UpstreamModelName, "chat") {
+	//	a.BotType = BotTypeCompletion
+	//} else {
+	//}
+	a.BotType = BotTypeChatFlow
+
 }
 }
 
 
 func (a *Adaptor) GetRequestURL(info *relaycommon.RelayInfo) (string, error) {
 func (a *Adaptor) GetRequestURL(info *relaycommon.RelayInfo) (string, error) {
@@ -64,7 +70,7 @@ func (a *Adaptor) SetupRequestHeader(c *gin.Context, req *http.Header, info *rel
 	return nil
 	return nil
 }
 }
 
 
-func (a *Adaptor) ConvertRequest(c *gin.Context, info *relaycommon.RelayInfo, request *dto.GeneralOpenAIRequest) (any, error) {
+func (a *Adaptor) ConvertOpenAIRequest(c *gin.Context, info *relaycommon.RelayInfo, request *dto.GeneralOpenAIRequest) (any, error) {
 	if request == nil {
 	if request == nil {
 		return nil, errors.New("request is nil")
 		return nil, errors.New("request is nil")
 	}
 	}

relay/channel/gemini/adaptor.go

@@ -21,6 +21,12 @@ import (
 type Adaptor struct {
 type Adaptor struct {
 }
 }
 
 
+func (a *Adaptor) ConvertClaudeRequest(*gin.Context, *relaycommon.RelayInfo, *dto.ClaudeRequest) (any, error) {
+	//TODO implement me
+	panic("implement me")
+	return nil, nil
+}
+
 func (a *Adaptor) ConvertAudioRequest(c *gin.Context, info *relaycommon.RelayInfo, request dto.AudioRequest) (io.Reader, error) {
 func (a *Adaptor) ConvertAudioRequest(c *gin.Context, info *relaycommon.RelayInfo, request dto.AudioRequest) (io.Reader, error) {
 	//TODO implement me
 	//TODO implement me
 	return nil, errors.New("not implemented")
 	return nil, errors.New("not implemented")
@@ -89,7 +95,7 @@ func (a *Adaptor) SetupRequestHeader(c *gin.Context, req *http.Header, info *rel
 	return nil
 	return nil
 }
 }
 
 
-func (a *Adaptor) ConvertRequest(c *gin.Context, info *relaycommon.RelayInfo, request *dto.GeneralOpenAIRequest) (any, error) {
+func (a *Adaptor) ConvertOpenAIRequest(c *gin.Context, info *relaycommon.RelayInfo, request *dto.GeneralOpenAIRequest) (any, error) {
 	if request == nil {
 	if request == nil {
 		return nil, errors.New("request is nil")
 		return nil, errors.New("request is nil")
 	}
 	}

relay/channel/jina/adaptor.go

@@ -8,13 +8,21 @@ import (
 	"net/http"
 	"net/http"
 	"one-api/dto"
 	"one-api/dto"
 	"one-api/relay/channel"
 	"one-api/relay/channel"
+	"one-api/relay/channel/openai"
 	relaycommon "one-api/relay/common"
 	relaycommon "one-api/relay/common"
+	"one-api/relay/common_handler"
 	"one-api/relay/constant"
 	"one-api/relay/constant"
 )
 )
 
 
 type Adaptor struct {
 type Adaptor struct {
 }
 }
 
 
+func (a *Adaptor) ConvertClaudeRequest(*gin.Context, *relaycommon.RelayInfo, *dto.ClaudeRequest) (any, error) {
+	//TODO implement me
+	panic("implement me")
+	return nil, nil
+}
+
 func (a *Adaptor) ConvertAudioRequest(c *gin.Context, info *relaycommon.RelayInfo, request dto.AudioRequest) (io.Reader, error) {
 func (a *Adaptor) ConvertAudioRequest(c *gin.Context, info *relaycommon.RelayInfo, request dto.AudioRequest) (io.Reader, error) {
 	//TODO implement me
 	//TODO implement me
 	return nil, errors.New("not implemented")
 	return nil, errors.New("not implemented")
@@ -43,7 +51,7 @@ func (a *Adaptor) SetupRequestHeader(c *gin.Context, req *http.Header, info *rel
 	return nil
 	return nil
 }
 }
 
 
-func (a *Adaptor) ConvertRequest(c *gin.Context, info *relaycommon.RelayInfo, request *dto.GeneralOpenAIRequest) (any, error) {
+func (a *Adaptor) ConvertOpenAIRequest(c *gin.Context, info *relaycommon.RelayInfo, request *dto.GeneralOpenAIRequest) (any, error) {
 	return request, nil
 	return request, nil
 }
 }
 
 
@@ -61,9 +69,9 @@ func (a *Adaptor) ConvertEmbeddingRequest(c *gin.Context, info *relaycommon.Rela
 
 
 func (a *Adaptor) DoResponse(c *gin.Context, resp *http.Response, info *relaycommon.RelayInfo) (usage any, err *dto.OpenAIErrorWithStatusCode) {
 func (a *Adaptor) DoResponse(c *gin.Context, resp *http.Response, info *relaycommon.RelayInfo) (usage any, err *dto.OpenAIErrorWithStatusCode) {
 	if info.RelayMode == constant.RelayModeRerank {
 	if info.RelayMode == constant.RelayModeRerank {
-		err, usage = JinaRerankHandler(c, resp)
+		err, usage = common_handler.RerankHandler(c, resp)
 	} else if info.RelayMode == constant.RelayModeEmbeddings {
 	} else if info.RelayMode == constant.RelayModeEmbeddings {
-		err, usage = jinaEmbeddingHandler(c, resp)
+		err, usage = openai.OpenaiHandler(c, resp, info)
 	}
 	}
 	return
 	return
 }
 }

relay/channel/jina/relay-jina.go

 package jina
 package jina
-
-import (
-	"encoding/json"
-	"github.com/gin-gonic/gin"
-	"io"
-	"net/http"
-	"one-api/dto"
-	"one-api/service"
-)
-
-func JinaRerankHandler(c *gin.Context, resp *http.Response) (*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 jinaResp dto.RerankResponse
-	err = json.Unmarshal(responseBody, &jinaResp)
-	if err != nil {
-		return service.OpenAIErrorWrapper(err, "unmarshal_response_body_failed", http.StatusInternalServerError), nil
-	}
-
-	jsonResponse, err := json.Marshal(jinaResp)
-	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, &jinaResp.Usage
-}
-
-func jinaEmbeddingHandler(c *gin.Context, resp *http.Response) (*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 jinaResp dto.OpenAIEmbeddingResponse
-	err = json.Unmarshal(responseBody, &jinaResp)
-	if err != nil {
-		return service.OpenAIErrorWrapper(err, "unmarshal_response_body_failed", http.StatusInternalServerError), nil
-	}
-
-	jsonResponse, err := json.Marshal(jinaResp)
-	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, &jinaResp.Usage
-}

relay/channel/mistral/adaptor.go

@@ -14,6 +14,12 @@ import (
 type Adaptor struct {
 type Adaptor struct {
 }
 }
 
 
+func (a *Adaptor) ConvertClaudeRequest(*gin.Context, *relaycommon.RelayInfo, *dto.ClaudeRequest) (any, error) {
+	//TODO implement me
+	panic("implement me")
+	return nil, nil
+}
+
 func (a *Adaptor) ConvertAudioRequest(c *gin.Context, info *relaycommon.RelayInfo, request dto.AudioRequest) (io.Reader, error) {
 func (a *Adaptor) ConvertAudioRequest(c *gin.Context, info *relaycommon.RelayInfo, request dto.AudioRequest) (io.Reader, error) {
 	//TODO implement me
 	//TODO implement me
 	return nil, errors.New("not implemented")
 	return nil, errors.New("not implemented")
@@ -37,7 +43,7 @@ func (a *Adaptor) SetupRequestHeader(c *gin.Context, req *http.Header, info *rel
 	return nil
 	return nil
 }
 }
 
 
-func (a *Adaptor) ConvertRequest(c *gin.Context, info *relaycommon.RelayInfo, request *dto.GeneralOpenAIRequest) (any, error) {
+func (a *Adaptor) ConvertOpenAIRequest(c *gin.Context, info *relaycommon.RelayInfo, request *dto.GeneralOpenAIRequest) (any, error) {
 	if request == nil {
 	if request == nil {
 		return nil, errors.New("request is nil")
 		return nil, errors.New("request is nil")
 	}
 	}
@@ -61,7 +67,7 @@ func (a *Adaptor) DoResponse(c *gin.Context, resp *http.Response, info *relaycom
 	if info.IsStream {
 	if info.IsStream {
 		err, usage = openai.OaiStreamHandler(c, resp, info)
 		err, usage = openai.OaiStreamHandler(c, resp, info)
 	} else {
 	} else {
-		err, usage = openai.OpenaiHandler(c, resp, info.PromptTokens, info.UpstreamModelName)
+		err, usage = openai.OpenaiHandler(c, resp, info)
 	}
 	}
 	return
 	return
 }
 }

relay/channel/mokaai/adaptor.go

@@ -16,6 +16,12 @@ import (
 type Adaptor struct {
 type Adaptor struct {
 }
 }
 
 
+func (a *Adaptor) ConvertClaudeRequest(*gin.Context, *relaycommon.RelayInfo, *dto.ClaudeRequest) (any, error) {
+	//TODO implement me
+	panic("implement me")
+	return nil, nil
+}
+
 func (a *Adaptor) ConvertAudioRequest(c *gin.Context, info *relaycommon.RelayInfo, request dto.AudioRequest) (io.Reader, error) {
 func (a *Adaptor) ConvertAudioRequest(c *gin.Context, info *relaycommon.RelayInfo, request dto.AudioRequest) (io.Reader, error) {
 	//TODO implement me
 	//TODO implement me
 	return nil, errors.New("not implemented")
 	return nil, errors.New("not implemented")
@@ -51,7 +57,7 @@ func (a *Adaptor) SetupRequestHeader(c *gin.Context, req *http.Header, info *rel
 	return nil
 	return nil
 }
 }
 
 
-func (a *Adaptor) ConvertRequest(c *gin.Context, info *relaycommon.RelayInfo, request *dto.GeneralOpenAIRequest) (any, error) {
+func (a *Adaptor) ConvertOpenAIRequest(c *gin.Context, info *relaycommon.RelayInfo, request *dto.GeneralOpenAIRequest) (any, error) {
 	if request == nil {
 	if request == nil {
 		return nil, errors.New("request is nil")
 		return nil, errors.New("request is nil")
 	}
 	}
@@ -73,13 +79,13 @@ func (a *Adaptor) DoRequest(c *gin.Context, info *relaycommon.RelayInfo, request
 }
 }
 
 
 func (a *Adaptor) DoResponse(c *gin.Context, resp *http.Response, info *relaycommon.RelayInfo) (usage any, err *dto.OpenAIErrorWithStatusCode) {
 func (a *Adaptor) DoResponse(c *gin.Context, resp *http.Response, info *relaycommon.RelayInfo) (usage any, err *dto.OpenAIErrorWithStatusCode) {
-		
+
 	switch info.RelayMode {
 	switch info.RelayMode {
 	case constant.RelayModeEmbeddings:
 	case constant.RelayModeEmbeddings:
 		err, usage = mokaEmbeddingHandler(c, resp)
 		err, usage = mokaEmbeddingHandler(c, resp)
 	default:
 	default:
 		// err, usage = mokaHandler(c, resp)
 		// err, usage = mokaHandler(c, resp)
-		
+
 	}
 	}
 	return
 	return
 }
 }

relay/channel/ollama/adaptor.go

@@ -15,6 +15,12 @@ import (
 type Adaptor struct {
 type Adaptor struct {
 }
 }
 
 
+func (a *Adaptor) ConvertClaudeRequest(*gin.Context, *relaycommon.RelayInfo, *dto.ClaudeRequest) (any, error) {
+	//TODO implement me
+	panic("implement me")
+	return nil, nil
+}
+
 func (a *Adaptor) ConvertAudioRequest(c *gin.Context, info *relaycommon.RelayInfo, request dto.AudioRequest) (io.Reader, error) {
 func (a *Adaptor) ConvertAudioRequest(c *gin.Context, info *relaycommon.RelayInfo, request dto.AudioRequest) (io.Reader, error) {
 	//TODO implement me
 	//TODO implement me
 	return nil, errors.New("not implemented")
 	return nil, errors.New("not implemented")
@@ -43,7 +49,7 @@ func (a *Adaptor) SetupRequestHeader(c *gin.Context, req *http.Header, info *rel
 	return nil
 	return nil
 }
 }
 
 
-func (a *Adaptor) ConvertRequest(c *gin.Context, info *relaycommon.RelayInfo, request *dto.GeneralOpenAIRequest) (any, error) {
+func (a *Adaptor) ConvertOpenAIRequest(c *gin.Context, info *relaycommon.RelayInfo, request *dto.GeneralOpenAIRequest) (any, error) {
 	if request == nil {
 	if request == nil {
 		return nil, errors.New("request is nil")
 		return nil, errors.New("request is nil")
 	}
 	}
@@ -69,7 +75,7 @@ func (a *Adaptor) DoResponse(c *gin.Context, resp *http.Response, info *relaycom
 		if info.RelayMode == relayconstant.RelayModeEmbeddings {
 		if info.RelayMode == relayconstant.RelayModeEmbeddings {
 			err, usage = ollamaEmbeddingHandler(c, resp, info.PromptTokens, info.UpstreamModelName, info.RelayMode)
 			err, usage = ollamaEmbeddingHandler(c, resp, info.PromptTokens, info.UpstreamModelName, info.RelayMode)
 		} else {
 		} else {
-			err, usage = openai.OpenaiHandler(c, resp, info.PromptTokens, info.UpstreamModelName)
+			err, usage = openai.OpenaiHandler(c, resp, info)
 		}
 		}
 	}
 	}
 	return
 	return

relay/channel/openai/adaptor.go

@@ -5,7 +5,6 @@ import (
 	"encoding/json"
 	"encoding/json"
 	"errors"
 	"errors"
 	"fmt"
 	"fmt"
-	"github.com/gin-gonic/gin"
 	"io"
 	"io"
 	"mime/multipart"
 	"mime/multipart"
 	"net/http"
 	"net/http"
@@ -14,13 +13,18 @@ import (
 	"one-api/dto"
 	"one-api/dto"
 	"one-api/relay/channel"
 	"one-api/relay/channel"
 	"one-api/relay/channel/ai360"
 	"one-api/relay/channel/ai360"
-	"one-api/relay/channel/jina"
 	"one-api/relay/channel/lingyiwanwu"
 	"one-api/relay/channel/lingyiwanwu"
 	"one-api/relay/channel/minimax"
 	"one-api/relay/channel/minimax"
 	"one-api/relay/channel/moonshot"
 	"one-api/relay/channel/moonshot"
+	"one-api/relay/channel/openrouter"
+	"one-api/relay/channel/xinference"
 	relaycommon "one-api/relay/common"
 	relaycommon "one-api/relay/common"
+	"one-api/relay/common_handler"
 	"one-api/relay/constant"
 	"one-api/relay/constant"
+	"one-api/service"
 	"strings"
 	"strings"
+
+	"github.com/gin-gonic/gin"
 )
 )
 
 
 type Adaptor struct {
 type Adaptor struct {
@@ -28,11 +32,39 @@ type Adaptor struct {
 	ResponseFormat string
 	ResponseFormat string
 }
 }
 
 
+func (a *Adaptor) ConvertClaudeRequest(c *gin.Context, info *relaycommon.RelayInfo, request *dto.ClaudeRequest) (any, error) {
+	if !strings.Contains(request.Model, "claude") {
+		return nil, fmt.Errorf("you are using openai channel type with path /v1/messages, only claude model supported convert, but got %s", request.Model)
+	}
+	aiRequest, err := service.ClaudeToOpenAIRequest(*request)
+	if err != nil {
+		return nil, err
+	}
+	if info.SupportStreamOptions {
+		aiRequest.StreamOptions = &dto.StreamOptions{
+			IncludeUsage: true,
+		}
+	}
+	return a.ConvertOpenAIRequest(c, info, aiRequest)
+}
+
 func (a *Adaptor) Init(info *relaycommon.RelayInfo) {
 func (a *Adaptor) Init(info *relaycommon.RelayInfo) {
 	a.ChannelType = info.ChannelType
 	a.ChannelType = info.ChannelType
+
+	// initialize ThinkingContentInfo when thinking_to_content is enabled
+	if think2Content, ok := info.ChannelSetting[constant2.ChannelSettingThinkingToContent].(bool); ok && think2Content {
+		info.ThinkingContentInfo = relaycommon.ThinkingContentInfo{
+			IsFirstThinkingContent:  true,
+			SendLastThinkingContent: false,
+			HasSentThinkingContent:  false,
+		}
+	}
 }
 }
 
 
 func (a *Adaptor) GetRequestURL(info *relaycommon.RelayInfo) (string, error) {
 func (a *Adaptor) GetRequestURL(info *relaycommon.RelayInfo) (string, error) {
+	if info.RelayFormat == relaycommon.RelayFormatClaude {
+		return fmt.Sprintf("%s/v1/chat/completions", info.BaseUrl), nil
+	}
 	if info.RelayMode == constant.RelayModeRealtime {
 	if info.RelayMode == constant.RelayModeRealtime {
 		if strings.HasPrefix(info.BaseUrl, "https://") {
 		if strings.HasPrefix(info.BaseUrl, "https://") {
 			baseUrl := strings.TrimPrefix(info.BaseUrl, "https://")
 			baseUrl := strings.TrimPrefix(info.BaseUrl, "https://")
@@ -101,14 +133,14 @@ func (a *Adaptor) SetupRequestHeader(c *gin.Context, header *http.Header, info *
 	} else {
 	} else {
 		header.Set("Authorization", "Bearer "+info.ApiKey)
 		header.Set("Authorization", "Bearer "+info.ApiKey)
 	}
 	}
-	//if info.ChannelType == common.ChannelTypeOpenRouter {
-	//	req.Header.Set("HTTP-Referer", "https://github.com/songquanpeng/one-api")
-	//	req.Header.Set("X-Title", "One API")
-	//}
+	if info.ChannelType == common.ChannelTypeOpenRouter {
+		header.Set("HTTP-Referer", "https://github.com/Calcium-Ion/new-api")
+		header.Set("X-Title", "New API")
+	}
 	return nil
 	return nil
 }
 }
 
 
-func (a *Adaptor) ConvertRequest(c *gin.Context, info *relaycommon.RelayInfo, request *dto.GeneralOpenAIRequest) (any, error) {
+func (a *Adaptor) ConvertOpenAIRequest(c *gin.Context, info *relaycommon.RelayInfo, request *dto.GeneralOpenAIRequest) (any, error) {
 	if request == nil {
 	if request == nil {
 		return nil, errors.New("request is nil")
 		return nil, errors.New("request is nil")
 	}
 	}
@@ -230,12 +262,12 @@ func (a *Adaptor) DoResponse(c *gin.Context, resp *http.Response, info *relaycom
 	case constant.RelayModeImagesGenerations:
 	case constant.RelayModeImagesGenerations:
 		err, usage = OpenaiTTSHandler(c, resp, info)
 		err, usage = OpenaiTTSHandler(c, resp, info)
 	case constant.RelayModeRerank:
 	case constant.RelayModeRerank:
-		err, usage = jina.JinaRerankHandler(c, resp)
+		err, usage = common_handler.RerankHandler(c, resp)
 	default:
 	default:
 		if info.IsStream {
 		if info.IsStream {
 			err, usage = OaiStreamHandler(c, resp, info)
 			err, usage = OaiStreamHandler(c, resp, info)
 		} else {
 		} else {
-			err, usage = OpenaiHandler(c, resp, info.PromptTokens, info.UpstreamModelName)
+			err, usage = OpenaiHandler(c, resp, info)
 		}
 		}
 	}
 	}
 	return
 	return
@@ -251,6 +283,10 @@ func (a *Adaptor) GetModelList() []string {
 		return lingyiwanwu.ModelList
 		return lingyiwanwu.ModelList
 	case common.ChannelTypeMiniMax:
 	case common.ChannelTypeMiniMax:
 		return minimax.ModelList
 		return minimax.ModelList
+	case common.ChannelTypeXinference:
+		return xinference.ModelList
+	case common.ChannelTypeOpenRouter:
+		return openrouter.ModelList
 	default:
 	default:
 		return ModelList
 		return ModelList
 	}
 	}
@@ -266,6 +302,10 @@ func (a *Adaptor) GetChannelName() string {
 		return lingyiwanwu.ChannelName
 		return lingyiwanwu.ChannelName
 	case common.ChannelTypeMiniMax:
 	case common.ChannelTypeMiniMax:
 		return minimax.ChannelName
 		return minimax.ChannelName
+	case common.ChannelTypeXinference:
+		return xinference.ChannelName
+	case common.ChannelTypeOpenRouter:
+		return openrouter.ChannelName
 	default:
 	default:
 		return ChannelName
 		return ChannelName
 	}
 	}

relay/channel/openai/helper.go

+package openai
+
+import (
+	"encoding/json"
+	"one-api/common"
+	"one-api/dto"
+	relaycommon "one-api/relay/common"
+	relayconstant "one-api/relay/constant"
+	"one-api/relay/helper"
+	"one-api/service"
+	"strings"
+
+	"github.com/gin-gonic/gin"
+)
+
+// 辅助函数
+func handleStreamFormat(c *gin.Context, info *relaycommon.RelayInfo, data string, forceFormat bool, thinkToContent bool) error {
+	info.SendResponseCount++
+	switch info.RelayFormat {
+	case relaycommon.RelayFormatOpenAI:
+		return sendStreamData(c, info, data, forceFormat, thinkToContent)
+	case relaycommon.RelayFormatClaude:
+		return handleClaudeFormat(c, data, info)
+	}
+	return nil
+}
+
+func handleClaudeFormat(c *gin.Context, data string, info *relaycommon.RelayInfo) error {
+	var streamResponse dto.ChatCompletionsStreamResponse
+	if err := json.Unmarshal(common.StringToByteSlice(data), &streamResponse); err != nil {
+		return err
+	}
+
+	claudeResponses := service.StreamResponseOpenAI2Claude(&streamResponse, info)
+	for _, resp := range claudeResponses {
+		helper.ClaudeData(c, *resp)
+	}
+	return nil
+}
+
+func processStreamResponse(item string, responseTextBuilder *strings.Builder, toolCount *int) error {
+	var streamResponse dto.ChatCompletionsStreamResponse
+	if err := json.Unmarshal(common.StringToByteSlice(item), &streamResponse); err != nil {
+		return err
+	}
+
+	for _, choice := range streamResponse.Choices {
+		responseTextBuilder.WriteString(choice.Delta.GetContentString())
+		responseTextBuilder.WriteString(choice.Delta.GetReasoningContent())
+		if choice.Delta.ToolCalls != nil {
+			if len(choice.Delta.ToolCalls) > *toolCount {
+				*toolCount = len(choice.Delta.ToolCalls)
+			}
+			for _, tool := range choice.Delta.ToolCalls {
+				responseTextBuilder.WriteString(tool.Function.Name)
+				responseTextBuilder.WriteString(tool.Function.Arguments)
+			}
+		}
+	}
+	return nil
+}
+
+func processTokens(relayMode int, streamItems []string, responseTextBuilder *strings.Builder, toolCount *int) error {
+	streamResp := "[" + strings.Join(streamItems, ",") + "]"
+
+	switch relayMode {
+	case relayconstant.RelayModeChatCompletions:
+		return processChatCompletions(streamResp, streamItems, responseTextBuilder, toolCount)
+	case relayconstant.RelayModeCompletions:
+		return processCompletions(streamResp, streamItems, responseTextBuilder)
+	}
+	return nil
+}
+
+func processChatCompletions(streamResp string, streamItems []string, responseTextBuilder *strings.Builder, toolCount *int) error {
+	var streamResponses []dto.ChatCompletionsStreamResponse
+	if err := json.Unmarshal(common.StringToByteSlice(streamResp), &streamResponses); err != nil {
+		// 一次性解析失败，逐个解析
+		common.SysError("error unmarshalling stream response: " + err.Error())
+		for _, item := range streamItems {
+			if err := processStreamResponse(item, responseTextBuilder, toolCount); err != nil {
+				common.SysError("error processing stream response: " + err.Error())
+			}
+		}
+		return nil
+	}
+
+	// 批量处理所有响应
+	for _, streamResponse := range streamResponses {
+		for _, choice := range streamResponse.Choices {
+			responseTextBuilder.WriteString(choice.Delta.GetContentString())
+			responseTextBuilder.WriteString(choice.Delta.GetReasoningContent())
+			if choice.Delta.ToolCalls != nil {
+				if len(choice.Delta.ToolCalls) > *toolCount {
+					*toolCount = len(choice.Delta.ToolCalls)
+				}
+				for _, tool := range choice.Delta.ToolCalls {
+					responseTextBuilder.WriteString(tool.Function.Name)
+					responseTextBuilder.WriteString(tool.Function.Arguments)
+				}
+			}
+		}
+	}
+	return nil
+}
+
+func processCompletions(streamResp string, streamItems []string, responseTextBuilder *strings.Builder) error {
+	var streamResponses []dto.CompletionsStreamResponse
+	if err := json.Unmarshal(common.StringToByteSlice(streamResp), &streamResponses); err != nil {
+		// 一次性解析失败，逐个解析
+		common.SysError("error unmarshalling stream response: " + err.Error())
+		for _, item := range streamItems {
+			var streamResponse dto.CompletionsStreamResponse
+			if err := json.Unmarshal(common.StringToByteSlice(item), &streamResponse); err != nil {
+				continue
+			}
+			for _, choice := range streamResponse.Choices {
+				responseTextBuilder.WriteString(choice.Text)
+			}
+		}
+		return nil
+	}
+
+	// 批量处理所有响应
+	for _, streamResponse := range streamResponses {
+		for _, choice := range streamResponse.Choices {
+			responseTextBuilder.WriteString(choice.Text)
+		}
+	}
+	return nil
+}
+
+func handleLastResponse(lastStreamData string, responseId *string, createAt *int64,
+	systemFingerprint *string, model *string, usage **dto.Usage,
+	containStreamUsage *bool, info *relaycommon.RelayInfo,
+	shouldSendLastResp *bool) error {
+
+	var lastStreamResponse dto.ChatCompletionsStreamResponse
+	if err := json.Unmarshal(common.StringToByteSlice(lastStreamData), &lastStreamResponse); err != nil {
+		return err
+	}
+
+	*responseId = lastStreamResponse.Id
+	*createAt = lastStreamResponse.Created
+	*systemFingerprint = lastStreamResponse.GetSystemFingerprint()
+	*model = lastStreamResponse.Model
+
+	if service.ValidUsage(lastStreamResponse.Usage) {
+		*containStreamUsage = true
+		*usage = lastStreamResponse.Usage
+		if !info.ShouldIncludeUsage {
+			*shouldSendLastResp = false
+		}
+	}
+
+	return nil
+}
+
+func handleFinalResponse(c *gin.Context, info *relaycommon.RelayInfo, lastStreamData string,
+	responseId string, createAt int64, model string, systemFingerprint string,
+	usage *dto.Usage, containStreamUsage bool) {
+
+	switch info.RelayFormat {
+	case relaycommon.RelayFormatOpenAI:
+		if info.ShouldIncludeUsage && !containStreamUsage {
+			response := helper.GenerateFinalUsageResponse(responseId, createAt, model, *usage)
+			response.SetSystemFingerprint(systemFingerprint)
+			helper.ObjectData(c, response)
+		}
+		helper.Done(c)
+
+	case relaycommon.RelayFormatClaude:
+		var streamResponse dto.ChatCompletionsStreamResponse
+		if err := json.Unmarshal(common.StringToByteSlice(lastStreamData), &streamResponse); err != nil {
+			common.SysError("error unmarshalling stream response: " + err.Error())
+			return
+		}
+
+		if !containStreamUsage {
+			streamResponse.Usage = usage
+		}
+
+		claudeResponses := service.StreamResponseOpenAI2Claude(&streamResponse, info)
+		for _, resp := range claudeResponses {
+			helper.ClaudeData(c, *resp)
+		}
+	}
+}

relay/channel/openai/relay-openai.go

@@ -12,7 +12,6 @@ import (
 	"one-api/constant"
 	"one-api/constant"
 	"one-api/dto"
 	"one-api/dto"
 	relaycommon "one-api/relay/common"
 	relaycommon "one-api/relay/common"
-	relayconstant "one-api/relay/constant"
 	"one-api/relay/helper"
 	"one-api/relay/helper"
 	"one-api/service"
 	"one-api/service"
 	"os"
 	"os"
@@ -66,6 +65,7 @@ func sendStreamData(c *gin.Context, info *relaycommon.RelayInfo, data string, fo
 				response.Choices[i].Delta.Reasoning = nil
 				response.Choices[i].Delta.Reasoning = nil
 			}
 			}
 			info.ThinkingContentInfo.IsFirstThinkingContent = false
 			info.ThinkingContentInfo.IsFirstThinkingContent = false
+			info.ThinkingContentInfo.HasSentThinkingContent = true
 			return helper.ObjectData(c, response)
 			return helper.ObjectData(c, response)
 		}
 		}
 	}
 	}
@@ -77,7 +77,8 @@ func sendStreamData(c *gin.Context, info *relaycommon.RelayInfo, data string, fo
 	// Process each choice
 	// Process each choice
 	for i, choice := range lastStreamResponse.Choices {
 	for i, choice := range lastStreamResponse.Choices {
 		// Handle transition from thinking to content
 		// Handle transition from thinking to content
-		if hasContent && !info.ThinkingContentInfo.SendLastThinkingContent {
+		// only send `</think>` tag when previous thinking content has been sent
+		if hasContent && !info.ThinkingContentInfo.SendLastThinkingContent && info.ThinkingContentInfo.HasSentThinkingContent {
 			response := lastStreamResponse.Copy()
 			response := lastStreamResponse.Copy()
 			for j := range response.Choices {
 			for j := range response.Choices {
 				response.Choices[j].Delta.SetContentString("\n</think>\n")
 				response.Choices[j].Delta.SetContentString("\n</think>\n")
@@ -88,7 +89,7 @@ func sendStreamData(c *gin.Context, info *relaycommon.RelayInfo, data string, fo
 			helper.ObjectData(c, response)
 			helper.ObjectData(c, response)
 		}
 		}
 
 
-		// Convert reasoning content to regular content
+		// Convert reasoning content to regular content if any
 		if len(choice.Delta.GetReasoningContent()) > 0 {
 		if len(choice.Delta.GetReasoningContent()) > 0 {
 			lastStreamResponse.Choices[i].Delta.SetContentString(choice.Delta.GetReasoningContent())
 			lastStreamResponse.Choices[i].Delta.SetContentString(choice.Delta.GetReasoningContent())
 			lastStreamResponse.Choices[i].Delta.ReasoningContent = nil
 			lastStreamResponse.Choices[i].Delta.ReasoningContent = nil
@@ -137,10 +138,11 @@ func OaiStreamHandler(c *gin.Context, resp *http.Response, info *relaycommon.Rel
 
 
 	helper.StreamScannerHandler(c, resp, info, func(data string) bool {
 	helper.StreamScannerHandler(c, resp, info, func(data string) bool {
 		if lastStreamData != "" {
 		if lastStreamData != "" {
-			err := sendStreamData(c, info, lastStreamData, forceFormat, thinkToContent)
+			err := handleStreamFormat(c, info, lastStreamData, forceFormat, thinkToContent)
 			if err != nil {
 			if err != nil {
-				common.LogError(c, "streaming error: "+err.Error())
+				common.SysError("error handling stream format: " + err.Error())
 			}
 			}
+			info.SetFirstResponseTime()
 		}
 		}
 		lastStreamData = data
 		lastStreamData = data
 		streamItems = append(streamItems, data)
 		streamItems = append(streamItems, data)
@@ -172,83 +174,9 @@ func OaiStreamHandler(c *gin.Context, resp *http.Response, info *relaycommon.Rel
 		sendStreamData(c, info, lastStreamData, forceFormat, thinkToContent)
 		sendStreamData(c, info, lastStreamData, forceFormat, thinkToContent)
 	}
 	}
 
 
-	// 计算token
-	streamResp := "[" + strings.Join(streamItems, ",") + "]"
-	switch info.RelayMode {
-	case relayconstant.RelayModeChatCompletions:
-		var streamResponses []dto.ChatCompletionsStreamResponse
-		err := json.Unmarshal(common.StringToByteSlice(streamResp), &streamResponses)
-		if err != nil {
-			// 一次性解析失败，逐个解析
-			common.SysError("error unmarshalling stream response: " + err.Error())
-			for _, item := range streamItems {
-				var streamResponse dto.ChatCompletionsStreamResponse
-				err := json.Unmarshal(common.StringToByteSlice(item), &streamResponse)
-				if err == nil {
-					//if service.ValidUsage(streamResponse.Usage) {
-					//	usage = streamResponse.Usage
-					//}
-					for _, choice := range streamResponse.Choices {
-						responseTextBuilder.WriteString(choice.Delta.GetContentString())
-
-						// handle both reasoning_content and reasoning
-						responseTextBuilder.WriteString(choice.Delta.GetReasoningContent())
-
-						if choice.Delta.ToolCalls != nil {
-							if len(choice.Delta.ToolCalls) > toolCount {
-								toolCount = len(choice.Delta.ToolCalls)
-							}
-							for _, tool := range choice.Delta.ToolCalls {
-								responseTextBuilder.WriteString(tool.Function.Name)
-								responseTextBuilder.WriteString(tool.Function.Arguments)
-							}
-						}
-					}
-				}
-			}
-		} else {
-			for _, streamResponse := range streamResponses {
-				//if service.ValidUsage(streamResponse.Usage) {
-				//	usage = streamResponse.Usage
-				//	containStreamUsage = true
-				//}
-				for _, choice := range streamResponse.Choices {
-					responseTextBuilder.WriteString(choice.Delta.GetContentString())
-					responseTextBuilder.WriteString(choice.Delta.GetReasoningContent()) // This will handle both reasoning_content and reasoning
-					if choice.Delta.ToolCalls != nil {
-						if len(choice.Delta.ToolCalls) > toolCount {
-							toolCount = len(choice.Delta.ToolCalls)
-						}
-						for _, tool := range choice.Delta.ToolCalls {
-							responseTextBuilder.WriteString(tool.Function.Name)
-							responseTextBuilder.WriteString(tool.Function.Arguments)
-						}
-					}
-				}
-			}
-		}
-	case relayconstant.RelayModeCompletions:
-		var streamResponses []dto.CompletionsStreamResponse
-		err := json.Unmarshal(common.StringToByteSlice(streamResp), &streamResponses)
-		if err != nil {
-			// 一次性解析失败，逐个解析
-			common.SysError("error unmarshalling stream response: " + err.Error())
-			for _, item := range streamItems {
-				var streamResponse dto.CompletionsStreamResponse
-				err := json.Unmarshal(common.StringToByteSlice(item), &streamResponse)
-				if err == nil {
-					for _, choice := range streamResponse.Choices {
-						responseTextBuilder.WriteString(choice.Text)
-					}
-				}
-			}
-		} else {
-			for _, streamResponse := range streamResponses {
-				for _, choice := range streamResponse.Choices {
-					responseTextBuilder.WriteString(choice.Text)
-				}
-			}
-		}
+	// 处理token计算
+	if err := processTokens(info.RelayMode, streamItems, &responseTextBuilder, &toolCount); err != nil {
+		common.SysError("error processing tokens: " + err.Error())
 	}
 	}
 
 
 	if !containStreamUsage {
 	if !containStreamUsage {
@@ -262,19 +190,12 @@ func OaiStreamHandler(c *gin.Context, resp *http.Response, info *relaycommon.Rel
 		}
 		}
 	}
 	}
 
 
-	if info.ShouldIncludeUsage && !containStreamUsage {
-		response := helper.GenerateFinalUsageResponse(responseId, createAt, model, *usage)
-		response.SetSystemFingerprint(systemFingerprint)
-		helper.ObjectData(c, response)
-	}
-
-	helper.Done(c)
+	handleFinalResponse(c, info, lastStreamData, responseId, createAt, model, systemFingerprint, usage, containStreamUsage)
 
 
-	//resp.Body.Close()
 	return nil, usage
 	return nil, usage
 }
 }
 
 
-func OpenaiHandler(c *gin.Context, resp *http.Response, promptTokens int, model string) (*dto.OpenAIErrorWithStatusCode, *dto.Usage) {
+func OpenaiHandler(c *gin.Context, resp *http.Response, info *relaycommon.RelayInfo) (*dto.OpenAIErrorWithStatusCode, *dto.Usage) {
 	var simpleResponse dto.SimpleResponse
 	var simpleResponse dto.SimpleResponse
 	responseBody, err := io.ReadAll(resp.Body)
 	responseBody, err := io.ReadAll(resp.Body)
 	if err != nil {
 	if err != nil {
@@ -312,13 +233,13 @@ func OpenaiHandler(c *gin.Context, resp *http.Response, promptTokens int, model
 	if simpleResponse.Usage.TotalTokens == 0 || (simpleResponse.Usage.PromptTokens == 0 && simpleResponse.Usage.CompletionTokens == 0) {
 	if simpleResponse.Usage.TotalTokens == 0 || (simpleResponse.Usage.PromptTokens == 0 && simpleResponse.Usage.CompletionTokens == 0) {
 		completionTokens := 0
 		completionTokens := 0
 		for _, choice := range simpleResponse.Choices {
 		for _, choice := range simpleResponse.Choices {
-			ctkm, _ := service.CountTextToken(choice.Message.StringContent()+choice.Message.ReasoningContent+choice.Message.Reasoning, model)
+			ctkm, _ := service.CountTextToken(choice.Message.StringContent()+choice.Message.ReasoningContent+choice.Message.Reasoning, info.UpstreamModelName)
 			completionTokens += ctkm
 			completionTokens += ctkm
 		}
 		}
 		simpleResponse.Usage = dto.Usage{
 		simpleResponse.Usage = dto.Usage{
-			PromptTokens:     promptTokens,
+			PromptTokens:     info.PromptTokens,
 			CompletionTokens: completionTokens,
 			CompletionTokens: completionTokens,
-			TotalTokens:      promptTokens + completionTokens,
+			TotalTokens:      info.PromptTokens + completionTokens,
 		}
 		}
 	}
 	}
 	return nil, &simpleResponse.Usage
 	return nil, &simpleResponse.Usage

relay/channel/openrouter/adaptor.go

-package openrouter
-
-import (
-	"errors"
-	"fmt"
-	"github.com/gin-gonic/gin"
-	"io"
-	"net/http"
-	"one-api/dto"
-	"one-api/relay/channel"
-	"one-api/relay/channel/openai"
-	relaycommon "one-api/relay/common"
-)
-
-type Adaptor struct {
-}
-
-func (a *Adaptor) ConvertAudioRequest(c *gin.Context, info *relaycommon.RelayInfo, request dto.AudioRequest) (io.Reader, error) {
-	//TODO implement me
-	return nil, errors.New("not implemented")
-}
-
-func (a *Adaptor) ConvertImageRequest(c *gin.Context, info *relaycommon.RelayInfo, request dto.ImageRequest) (any, error) {
-	//TODO implement me
-	return nil, errors.New("not implemented")
-}
-
-func (a *Adaptor) Init(info *relaycommon.RelayInfo) {
-}
-
-func (a *Adaptor) GetRequestURL(info *relaycommon.RelayInfo) (string, error) {
-	return fmt.Sprintf("%s/v1/chat/completions", info.BaseUrl), nil
-}
-
-func (a *Adaptor) SetupRequestHeader(c *gin.Context, req *http.Header, info *relaycommon.RelayInfo) error {
-	channel.SetupApiRequestHeader(info, c, req)
-	req.Set("Authorization", fmt.Sprintf("Bearer %s", info.ApiKey))
-	req.Set("HTTP-Referer", "https://github.com/Calcium-Ion/new-api")
-	req.Set("X-Title", "New API")
-	return nil
-}
-
-func (a *Adaptor) ConvertRequest(c *gin.Context, info *relaycommon.RelayInfo, request *dto.GeneralOpenAIRequest) (any, error) {
-	return request, nil
-}
-
-func (a *Adaptor) DoRequest(c *gin.Context, info *relaycommon.RelayInfo, requestBody io.Reader) (any, error) {
-	return channel.DoApiRequest(a, c, info, requestBody)
-}
-
-func (a *Adaptor) ConvertRerankRequest(c *gin.Context, relayMode int, request dto.RerankRequest) (any, error) {
-	return nil, errors.New("not implemented")
-}
-
-func (a *Adaptor) ConvertEmbeddingRequest(c *gin.Context, info *relaycommon.RelayInfo, request dto.EmbeddingRequest) (any, error) {
-	return nil, errors.New("not implemented")
-}
-
-func (a *Adaptor) DoResponse(c *gin.Context, resp *http.Response, info *relaycommon.RelayInfo) (usage any, err *dto.OpenAIErrorWithStatusCode) {
-	if info.IsStream {
-		err, usage = openai.OaiStreamHandler(c, resp, info)
-	} else {
-		err, usage = openai.OpenaiHandler(c, resp, info.PromptTokens, info.UpstreamModelName)
-	}
-	return
-}
-
-func (a *Adaptor) GetModelList() []string {
-	return ModelList
-}
-
-func (a *Adaptor) GetChannelName() string {
-	return ChannelName
-}

relay/channel/palm/adaptor.go

@@ -15,6 +15,12 @@ import (
 type Adaptor struct {
 type Adaptor struct {
 }
 }
 
 
+func (a *Adaptor) ConvertClaudeRequest(*gin.Context, *relaycommon.RelayInfo, *dto.ClaudeRequest) (any, error) {
+	//TODO implement me
+	panic("implement me")
+	return nil, nil
+}
+
 func (a *Adaptor) ConvertAudioRequest(c *gin.Context, info *relaycommon.RelayInfo, request dto.AudioRequest) (io.Reader, error) {
 func (a *Adaptor) ConvertAudioRequest(c *gin.Context, info *relaycommon.RelayInfo, request dto.AudioRequest) (io.Reader, error) {
 	//TODO implement me
 	//TODO implement me
 	return nil, errors.New("not implemented")
 	return nil, errors.New("not implemented")
@@ -38,7 +44,7 @@ func (a *Adaptor) SetupRequestHeader(c *gin.Context, req *http.Header, info *rel
 	return nil
 	return nil
 }
 }
 
 
-func (a *Adaptor) ConvertRequest(c *gin.Context, info *relaycommon.RelayInfo, request *dto.GeneralOpenAIRequest) (any, error) {
+func (a *Adaptor) ConvertOpenAIRequest(c *gin.Context, info *relaycommon.RelayInfo, request *dto.GeneralOpenAIRequest) (any, error) {
 	if request == nil {
 	if request == nil {
 		return nil, errors.New("request is nil")
 		return nil, errors.New("request is nil")
 	}
 	}
@@ -54,7 +60,6 @@ func (a *Adaptor) ConvertEmbeddingRequest(c *gin.Context, info *relaycommon.Rela
 	return nil, errors.New("not implemented")
 	return nil, errors.New("not implemented")
 }
 }
 
 
-
 func (a *Adaptor) DoRequest(c *gin.Context, info *relaycommon.RelayInfo, requestBody io.Reader) (any, error) {
 func (a *Adaptor) DoRequest(c *gin.Context, info *relaycommon.RelayInfo, requestBody io.Reader) (any, error) {
 	return channel.DoApiRequest(a, c, info, requestBody)
 	return channel.DoApiRequest(a, c, info, requestBody)
 }
 }

relay/channel/perplexity/adaptor.go

@@ -15,6 +15,12 @@ import (
 type Adaptor struct {
 type Adaptor struct {
 }
 }
 
 
+func (a *Adaptor) ConvertClaudeRequest(*gin.Context, *relaycommon.RelayInfo, *dto.ClaudeRequest) (any, error) {
+	//TODO implement me
+	panic("implement me")
+	return nil, nil
+}
+
 func (a *Adaptor) ConvertAudioRequest(c *gin.Context, info *relaycommon.RelayInfo, request dto.AudioRequest) (io.Reader, error) {
 func (a *Adaptor) ConvertAudioRequest(c *gin.Context, info *relaycommon.RelayInfo, request dto.AudioRequest) (io.Reader, error) {
 	//TODO implement me
 	//TODO implement me
 	return nil, errors.New("not implemented")
 	return nil, errors.New("not implemented")
@@ -38,7 +44,7 @@ func (a *Adaptor) SetupRequestHeader(c *gin.Context, req *http.Header, info *rel
 	return nil
 	return nil
 }
 }
 
 
-func (a *Adaptor) ConvertRequest(c *gin.Context, info *relaycommon.RelayInfo, request *dto.GeneralOpenAIRequest) (any, error) {
+func (a *Adaptor) ConvertOpenAIRequest(c *gin.Context, info *relaycommon.RelayInfo, request *dto.GeneralOpenAIRequest) (any, error) {
 	if request == nil {
 	if request == nil {
 		return nil, errors.New("request is nil")
 		return nil, errors.New("request is nil")
 	}
 	}
@@ -57,7 +63,6 @@ func (a *Adaptor) ConvertEmbeddingRequest(c *gin.Context, info *relaycommon.Rela
 	return nil, errors.New("not implemented")
 	return nil, errors.New("not implemented")
 }
 }
 
 
-
 func (a *Adaptor) DoRequest(c *gin.Context, info *relaycommon.RelayInfo, requestBody io.Reader) (any, error) {
 func (a *Adaptor) DoRequest(c *gin.Context, info *relaycommon.RelayInfo, requestBody io.Reader) (any, error) {
 	return channel.DoApiRequest(a, c, info, requestBody)
 	return channel.DoApiRequest(a, c, info, requestBody)
 }
 }
@@ -66,7 +71,7 @@ func (a *Adaptor) DoResponse(c *gin.Context, resp *http.Response, info *relaycom
 	if info.IsStream {
 	if info.IsStream {
 		err, usage = openai.OaiStreamHandler(c, resp, info)
 		err, usage = openai.OaiStreamHandler(c, resp, info)
 	} else {
 	} else {
-		err, usage = openai.OpenaiHandler(c, resp, info.PromptTokens, info.UpstreamModelName)
+		err, usage = openai.OpenaiHandler(c, resp, info)
 	}
 	}
 	return
 	return
 }
 }

relay/channel/siliconflow/adaptor.go

@@ -16,6 +16,12 @@ import (
 type Adaptor struct {
 type Adaptor struct {
 }
 }
 
 
+func (a *Adaptor) ConvertClaudeRequest(*gin.Context, *relaycommon.RelayInfo, *dto.ClaudeRequest) (any, error) {
+	//TODO implement me
+	panic("implement me")
+	return nil, nil
+}
+
 func (a *Adaptor) ConvertAudioRequest(c *gin.Context, info *relaycommon.RelayInfo, request dto.AudioRequest) (io.Reader, error) {
 func (a *Adaptor) ConvertAudioRequest(c *gin.Context, info *relaycommon.RelayInfo, request dto.AudioRequest) (io.Reader, error) {
 	//TODO implement me
 	//TODO implement me
 	return nil, errors.New("not implemented")
 	return nil, errors.New("not implemented")
@@ -48,7 +54,7 @@ func (a *Adaptor) SetupRequestHeader(c *gin.Context, req *http.Header, info *rel
 	return nil
 	return nil
 }
 }
 
 
-func (a *Adaptor) ConvertRequest(c *gin.Context, info *relaycommon.RelayInfo, request *dto.GeneralOpenAIRequest) (any, error) {
+func (a *Adaptor) ConvertOpenAIRequest(c *gin.Context, info *relaycommon.RelayInfo, request *dto.GeneralOpenAIRequest) (any, error) {
 	return request, nil
 	return request, nil
 }
 }
 
 
@@ -72,16 +78,16 @@ func (a *Adaptor) DoResponse(c *gin.Context, resp *http.Response, info *relaycom
 		if info.IsStream {
 		if info.IsStream {
 			err, usage = openai.OaiStreamHandler(c, resp, info)
 			err, usage = openai.OaiStreamHandler(c, resp, info)
 		} else {
 		} else {
-			err, usage = openai.OpenaiHandler(c, resp, info.PromptTokens, info.UpstreamModelName)
+			err, usage = openai.OpenaiHandler(c, resp, info)
 		}
 		}
 	case constant.RelayModeCompletions:
 	case constant.RelayModeCompletions:
 		if info.IsStream {
 		if info.IsStream {
 			err, usage = openai.OaiStreamHandler(c, resp, info)
 			err, usage = openai.OaiStreamHandler(c, resp, info)
 		} else {
 		} else {
-			err, usage = openai.OpenaiHandler(c, resp, info.PromptTokens, info.UpstreamModelName)
+			err, usage = openai.OpenaiHandler(c, resp, info)
 		}
 		}
 	case constant.RelayModeEmbeddings:
 	case constant.RelayModeEmbeddings:
-		err, usage = openai.OpenaiHandler(c, resp, info.PromptTokens, info.UpstreamModelName)
+		err, usage = openai.OpenaiHandler(c, resp, info)
 	}
 	}
 	return
 	return
 }
 }

relay/channel/tencent/adaptor.go

@@ -23,6 +23,12 @@ type Adaptor struct {
 	Timestamp int64
 	Timestamp int64
 }
 }
 
 
+func (a *Adaptor) ConvertClaudeRequest(*gin.Context, *relaycommon.RelayInfo, *dto.ClaudeRequest) (any, error) {
+	//TODO implement me
+	panic("implement me")
+	return nil, nil
+}
+
 func (a *Adaptor) ConvertAudioRequest(c *gin.Context, info *relaycommon.RelayInfo, request dto.AudioRequest) (io.Reader, error) {
 func (a *Adaptor) ConvertAudioRequest(c *gin.Context, info *relaycommon.RelayInfo, request dto.AudioRequest) (io.Reader, error) {
 	//TODO implement me
 	//TODO implement me
 	return nil, errors.New("not implemented")
 	return nil, errors.New("not implemented")
@@ -52,7 +58,7 @@ func (a *Adaptor) SetupRequestHeader(c *gin.Context, req *http.Header, info *rel
 	return nil
 	return nil
 }
 }
 
 
-func (a *Adaptor) ConvertRequest(c *gin.Context, info *relaycommon.RelayInfo, request *dto.GeneralOpenAIRequest) (any, error) {
+func (a *Adaptor) ConvertOpenAIRequest(c *gin.Context, info *relaycommon.RelayInfo, request *dto.GeneralOpenAIRequest) (any, error) {
 	if request == nil {
 	if request == nil {
 		return nil, errors.New("request is nil")
 		return nil, errors.New("request is nil")
 	}
 	}
@@ -78,7 +84,6 @@ func (a *Adaptor) ConvertEmbeddingRequest(c *gin.Context, info *relaycommon.Rela
 	return nil, errors.New("not implemented")
 	return nil, errors.New("not implemented")
 }
 }
 
 
-
 func (a *Adaptor) DoRequest(c *gin.Context, info *relaycommon.RelayInfo, requestBody io.Reader) (any, error) {
 func (a *Adaptor) DoRequest(c *gin.Context, info *relaycommon.RelayInfo, requestBody io.Reader) (any, error) {
 	return channel.DoApiRequest(a, c, info, requestBody)
 	return channel.DoApiRequest(a, c, info, requestBody)
 }
 }

relay/channel/vertex/adaptor.go

@@ -38,6 +38,9 @@ type Adaptor struct {
 	AccountCredentials Credentials
 	AccountCredentials Credentials
 }
 }
 
 
+func (a *Adaptor) ConvertClaudeRequest(c *gin.Context, info *relaycommon.RelayInfo, request *dto.ClaudeRequest) (any, error) {
+	return request, nil
+}
 func (a *Adaptor) ConvertAudioRequest(c *gin.Context, info *relaycommon.RelayInfo, request dto.AudioRequest) (io.Reader, error) {
 func (a *Adaptor) ConvertAudioRequest(c *gin.Context, info *relaycommon.RelayInfo, request dto.AudioRequest) (io.Reader, error) {
 	//TODO implement me
 	//TODO implement me
 	return nil, errors.New("not implemented")
 	return nil, errors.New("not implemented")
@@ -119,7 +122,7 @@ func (a *Adaptor) SetupRequestHeader(c *gin.Context, req *http.Header, info *rel
 	return nil
 	return nil
 }
 }
 
 
-func (a *Adaptor) ConvertRequest(c *gin.Context, info *relaycommon.RelayInfo, request *dto.GeneralOpenAIRequest) (any, error) {
+func (a *Adaptor) ConvertOpenAIRequest(c *gin.Context, info *relaycommon.RelayInfo, request *dto.GeneralOpenAIRequest) (any, error) {
 	if request == nil {
 	if request == nil {
 		return nil, errors.New("request is nil")
 		return nil, errors.New("request is nil")
 	}
 	}
@@ -175,7 +178,7 @@ func (a *Adaptor) DoResponse(c *gin.Context, resp *http.Response, info *relaycom
 		case RequestModeGemini:
 		case RequestModeGemini:
 			err, usage = gemini.GeminiChatHandler(c, resp, info)
 			err, usage = gemini.GeminiChatHandler(c, resp, info)
 		case RequestModeLlama:
 		case RequestModeLlama:
-			err, usage = openai.OpenaiHandler(c, resp, info.PromptTokens, info.OriginModelName)
+			err, usage = openai.OpenaiHandler(c, resp, info)
 		}
 		}
 	}
 	}
 	return
 	return

relay/channel/vertex/dto.go

 package vertex
 package vertex
 
 
 import (
 import (
-	"one-api/relay/channel/claude"
+	"one-api/dto"
 )
 )
 
 
 type VertexAIClaudeRequest struct {
 type VertexAIClaudeRequest struct {
-	AnthropicVersion string                 `json:"anthropic_version"`
-	Messages         []claude.ClaudeMessage `json:"messages"`
-	System           any                    `json:"system,omitempty"`
-	MaxTokens        uint                   `json:"max_tokens,omitempty"`
-	StopSequences    []string               `json:"stop_sequences,omitempty"`
-	Stream           bool                   `json:"stream,omitempty"`
-	Temperature      *float64               `json:"temperature,omitempty"`
-	TopP             float64                `json:"top_p,omitempty"`
-	TopK             int                    `json:"top_k,omitempty"`
-	Tools            any                    `json:"tools,omitempty"`
-	ToolChoice       any                    `json:"tool_choice,omitempty"`
-	Thinking         *claude.Thinking       `json:"thinking,omitempty"`
+	AnthropicVersion string              `json:"anthropic_version"`
+	Messages         []dto.ClaudeMessage `json:"messages"`
+	System           any                 `json:"system,omitempty"`
+	MaxTokens        uint                `json:"max_tokens,omitempty"`
+	StopSequences    []string            `json:"stop_sequences,omitempty"`
+	Stream           bool                `json:"stream,omitempty"`
+	Temperature      *float64            `json:"temperature,omitempty"`
+	TopP             float64             `json:"top_p,omitempty"`
+	TopK             int                 `json:"top_k,omitempty"`
+	Tools            any                 `json:"tools,omitempty"`
+	ToolChoice       any                 `json:"tool_choice,omitempty"`
+	Thinking         *dto.Thinking       `json:"thinking,omitempty"`
 }
 }
 
 
-func copyRequest(req *claude.ClaudeRequest, version string) *VertexAIClaudeRequest {
+func copyRequest(req *dto.ClaudeRequest, version string) *VertexAIClaudeRequest {
 	return &VertexAIClaudeRequest{
 	return &VertexAIClaudeRequest{
 		AnthropicVersion: version,
 		AnthropicVersion: version,
 		System:           req.System,
 		System:           req.System,

relay/channel/volcengine/adaptor.go

@@ -17,6 +17,12 @@ import (
 type Adaptor struct {
 type Adaptor struct {
 }
 }
 
 
+func (a *Adaptor) ConvertClaudeRequest(*gin.Context, *relaycommon.RelayInfo, *dto.ClaudeRequest) (any, error) {
+	//TODO implement me
+	panic("implement me")
+	return nil, nil
+}
+
 func (a *Adaptor) ConvertAudioRequest(c *gin.Context, info *relaycommon.RelayInfo, request dto.AudioRequest) (io.Reader, error) {
 func (a *Adaptor) ConvertAudioRequest(c *gin.Context, info *relaycommon.RelayInfo, request dto.AudioRequest) (io.Reader, error) {
 	//TODO implement me
 	//TODO implement me
 	return nil, errors.New("not implemented")
 	return nil, errors.New("not implemented")
@@ -50,7 +56,7 @@ func (a *Adaptor) SetupRequestHeader(c *gin.Context, req *http.Header, info *rel
 	return nil
 	return nil
 }
 }
 
 
-func (a *Adaptor) ConvertRequest(c *gin.Context, info *relaycommon.RelayInfo, request *dto.GeneralOpenAIRequest) (any, error) {
+func (a *Adaptor) ConvertOpenAIRequest(c *gin.Context, info *relaycommon.RelayInfo, request *dto.GeneralOpenAIRequest) (any, error) {
 	if request == nil {
 	if request == nil {
 		return nil, errors.New("request is nil")
 		return nil, errors.New("request is nil")
 	}
 	}
@@ -75,10 +81,10 @@ func (a *Adaptor) DoResponse(c *gin.Context, resp *http.Response, info *relaycom
 		if info.IsStream {
 		if info.IsStream {
 			err, usage = openai.OaiStreamHandler(c, resp, info)
 			err, usage = openai.OaiStreamHandler(c, resp, info)
 		} else {
 		} else {
-			err, usage = openai.OpenaiHandler(c, resp, info.PromptTokens, info.UpstreamModelName)
+			err, usage = openai.OpenaiHandler(c, resp, info)
 		}
 		}
 	case constant.RelayModeEmbeddings:
 	case constant.RelayModeEmbeddings:
-		err, usage = openai.OpenaiHandler(c, resp, info.PromptTokens, info.UpstreamModelName)
+		err, usage = openai.OpenaiHandler(c, resp, info)
 	}
 	}
 	return
 	return
 }
 }

relay/channel/xinference/constant.go

+package xinference
+
+var ModelList = []string{
+	"bge-reranker-v2-m3",
+}
+
+var ChannelName = "xinference"

relay/channel/xunfei/adaptor.go

@@ -16,6 +16,12 @@ type Adaptor struct {
 	request *dto.GeneralOpenAIRequest
 	request *dto.GeneralOpenAIRequest
 }
 }
 
 
+func (a *Adaptor) ConvertClaudeRequest(*gin.Context, *relaycommon.RelayInfo, *dto.ClaudeRequest) (any, error) {
+	//TODO implement me
+	panic("implement me")
+	return nil, nil
+}
+
 func (a *Adaptor) ConvertAudioRequest(c *gin.Context, info *relaycommon.RelayInfo, request dto.AudioRequest) (io.Reader, error) {
 func (a *Adaptor) ConvertAudioRequest(c *gin.Context, info *relaycommon.RelayInfo, request dto.AudioRequest) (io.Reader, error) {
 	//TODO implement me
 	//TODO implement me
 	return nil, errors.New("not implemented")
 	return nil, errors.New("not implemented")
@@ -38,7 +44,7 @@ func (a *Adaptor) SetupRequestHeader(c *gin.Context, req *http.Header, info *rel
 	return nil
 	return nil
 }
 }
 
 
-func (a *Adaptor) ConvertRequest(c *gin.Context, info *relaycommon.RelayInfo, request *dto.GeneralOpenAIRequest) (any, error) {
+func (a *Adaptor) ConvertOpenAIRequest(c *gin.Context, info *relaycommon.RelayInfo, request *dto.GeneralOpenAIRequest) (any, error) {
 	if request == nil {
 	if request == nil {
 		return nil, errors.New("request is nil")
 		return nil, errors.New("request is nil")
 	}
 	}
@@ -55,7 +61,6 @@ func (a *Adaptor) ConvertEmbeddingRequest(c *gin.Context, info *relaycommon.Rela
 	return nil, errors.New("not implemented")
 	return nil, errors.New("not implemented")
 }
 }
 
 
-
 func (a *Adaptor) DoRequest(c *gin.Context, info *relaycommon.RelayInfo, requestBody io.Reader) (any, error) {
 func (a *Adaptor) DoRequest(c *gin.Context, info *relaycommon.RelayInfo, requestBody io.Reader) (any, error) {
 	// xunfei's request is not http request, so we don't need to do anything here
 	// xunfei's request is not http request, so we don't need to do anything here
 	dummyResp := &http.Response{}
 	dummyResp := &http.Response{}

relay/channel/zhipu/adaptor.go

@@ -14,6 +14,12 @@ import (
 type Adaptor struct {
 type Adaptor struct {
 }
 }
 
 
+func (a *Adaptor) ConvertClaudeRequest(*gin.Context, *relaycommon.RelayInfo, *dto.ClaudeRequest) (any, error) {
+	//TODO implement me
+	panic("implement me")
+	return nil, nil
+}
+
 func (a *Adaptor) ConvertAudioRequest(c *gin.Context, info *relaycommon.RelayInfo, request dto.AudioRequest) (io.Reader, error) {
 func (a *Adaptor) ConvertAudioRequest(c *gin.Context, info *relaycommon.RelayInfo, request dto.AudioRequest) (io.Reader, error) {
 	//TODO implement me
 	//TODO implement me
 	return nil, errors.New("not implemented")
 	return nil, errors.New("not implemented")
@@ -42,7 +48,7 @@ func (a *Adaptor) SetupRequestHeader(c *gin.Context, req *http.Header, info *rel
 	return nil
 	return nil
 }
 }
 
 
-func (a *Adaptor) ConvertRequest(c *gin.Context, info *relaycommon.RelayInfo, request *dto.GeneralOpenAIRequest) (any, error) {
+func (a *Adaptor) ConvertOpenAIRequest(c *gin.Context, info *relaycommon.RelayInfo, request *dto.GeneralOpenAIRequest) (any, error) {
 	if request == nil {
 	if request == nil {
 		return nil, errors.New("request is nil")
 		return nil, errors.New("request is nil")
 	}
 	}
@@ -61,7 +67,6 @@ func (a *Adaptor) ConvertEmbeddingRequest(c *gin.Context, info *relaycommon.Rela
 	return nil, errors.New("not implemented")
 	return nil, errors.New("not implemented")
 }
 }
 
 
-
 func (a *Adaptor) DoRequest(c *gin.Context, info *relaycommon.RelayInfo, requestBody io.Reader) (any, error) {
 func (a *Adaptor) DoRequest(c *gin.Context, info *relaycommon.RelayInfo, requestBody io.Reader) (any, error) {
 	return channel.DoApiRequest(a, c, info, requestBody)
 	return channel.DoApiRequest(a, c, info, requestBody)
 }
 }

relay/channel/zhipu_4v/adaptor.go

@@ -15,6 +15,12 @@ import (
 type Adaptor struct {
 type Adaptor struct {
 }
 }
 
 
+func (a *Adaptor) ConvertClaudeRequest(*gin.Context, *relaycommon.RelayInfo, *dto.ClaudeRequest) (any, error) {
+	//TODO implement me
+	panic("implement me")
+	return nil, nil
+}
+
 func (a *Adaptor) ConvertAudioRequest(c *gin.Context, info *relaycommon.RelayInfo, request dto.AudioRequest) (io.Reader, error) {
 func (a *Adaptor) ConvertAudioRequest(c *gin.Context, info *relaycommon.RelayInfo, request dto.AudioRequest) (io.Reader, error) {
 	//TODO implement me
 	//TODO implement me
 	return nil, errors.New("not implemented")
 	return nil, errors.New("not implemented")
@@ -39,7 +45,7 @@ func (a *Adaptor) SetupRequestHeader(c *gin.Context, req *http.Header, info *rel
 	return nil
 	return nil
 }
 }
 
 
-func (a *Adaptor) ConvertRequest(c *gin.Context, info *relaycommon.RelayInfo, request *dto.GeneralOpenAIRequest) (any, error) {
+func (a *Adaptor) ConvertOpenAIRequest(c *gin.Context, info *relaycommon.RelayInfo, request *dto.GeneralOpenAIRequest) (any, error) {
 	if request == nil {
 	if request == nil {
 		return nil, errors.New("request is nil")
 		return nil, errors.New("request is nil")
 	}
 	}
@@ -58,7 +64,6 @@ func (a *Adaptor) ConvertEmbeddingRequest(c *gin.Context, info *relaycommon.Rela
 	return nil, errors.New("not implemented")
 	return nil, errors.New("not implemented")
 }
 }
 
 
-
 func (a *Adaptor) DoRequest(c *gin.Context, info *relaycommon.RelayInfo, requestBody io.Reader) (any, error) {
 func (a *Adaptor) DoRequest(c *gin.Context, info *relaycommon.RelayInfo, requestBody io.Reader) (any, error) {
 	return channel.DoApiRequest(a, c, info, requestBody)
 	return channel.DoApiRequest(a, c, info, requestBody)
 }
 }
@@ -67,7 +72,7 @@ func (a *Adaptor) DoResponse(c *gin.Context, resp *http.Response, info *relaycom
 	if info.IsStream {
 	if info.IsStream {
 		err, usage = openai.OaiStreamHandler(c, resp, info)
 		err, usage = openai.OaiStreamHandler(c, resp, info)
 	} else {
 	} else {
-		err, usage = openai.OpenaiHandler(c, resp, info.PromptTokens, info.UpstreamModelName)
+		err, usage = openai.OpenaiHandler(c, resp, info)
 	}
 	}
 	return
 	return
 }
 }

relay/claude_handler.go

+package relay
+
+import (
+	"bytes"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"github.com/gin-gonic/gin"
+	"io"
+	"net/http"
+	"one-api/common"
+	"one-api/dto"
+	relaycommon "one-api/relay/common"
+	"one-api/relay/helper"
+	"one-api/service"
+	"one-api/setting/model_setting"
+	"strings"
+)
+
+func getAndValidateClaudeRequest(c *gin.Context) (textRequest *dto.ClaudeRequest, err error) {
+	textRequest = &dto.ClaudeRequest{}
+	err = c.ShouldBindJSON(textRequest)
+	if err != nil {
+		return nil, err
+	}
+	if textRequest.Messages == nil || len(textRequest.Messages) == 0 {
+		return nil, errors.New("field messages is required")
+	}
+	if textRequest.Model == "" {
+		return nil, errors.New("field model is required")
+	}
+	return textRequest, nil
+}
+
+func ClaudeHelper(c *gin.Context) (claudeError *dto.ClaudeErrorWithStatusCode) {
+
+	relayInfo := relaycommon.GenRelayInfoClaude(c)
+
+	// get & validate textRequest 获取并验证文本请求
+	textRequest, err := getAndValidateClaudeRequest(c)
+	if err != nil {
+		return service.ClaudeErrorWrapperLocal(err, "invalid_claude_request", http.StatusBadRequest)
+	}
+
+	if textRequest.Stream {
+		relayInfo.IsStream = true
+	}
+
+	err = helper.ModelMappedHelper(c, relayInfo)
+	if err != nil {
+		return service.ClaudeErrorWrapperLocal(err, "model_mapped_error", http.StatusInternalServerError)
+	}
+
+	textRequest.Model = relayInfo.UpstreamModelName
+
+	promptTokens, err := getClaudePromptTokens(textRequest, relayInfo)
+	// count messages token error 计算promptTokens错误
+	if err != nil {
+		return service.ClaudeErrorWrapperLocal(err, "count_token_messages_failed", http.StatusInternalServerError)
+	}
+
+	priceData, err := helper.ModelPriceHelper(c, relayInfo, promptTokens, int(textRequest.MaxTokens))
+	if err != nil {
+		return service.ClaudeErrorWrapperLocal(err, "model_price_error", http.StatusInternalServerError)
+	}
+
+	// pre-consume quota 预消耗配额
+	preConsumedQuota, userQuota, openaiErr := preConsumeQuota(c, priceData.ShouldPreConsumedQuota, relayInfo)
+
+	if openaiErr != nil {
+		return service.OpenAIErrorToClaudeError(openaiErr)
+	}
+	defer func() {
+		if openaiErr != nil {
+			returnPreConsumedQuota(c, relayInfo, userQuota, preConsumedQuota)
+		}
+	}()
+
+	adaptor := GetAdaptor(relayInfo.ApiType)
+	if adaptor == nil {
+		return service.ClaudeErrorWrapperLocal(fmt.Errorf("invalid api type: %d", relayInfo.ApiType), "invalid_api_type", http.StatusBadRequest)
+	}
+	adaptor.Init(relayInfo)
+	var requestBody io.Reader
+
+	if textRequest.MaxTokens == 0 {
+		textRequest.MaxTokens = uint(model_setting.GetClaudeSettings().GetDefaultMaxTokens(textRequest.Model))
+	}
+
+	if model_setting.GetClaudeSettings().ThinkingAdapterEnabled &&
+		strings.HasSuffix(textRequest.Model, "-thinking") {
+		if textRequest.Thinking == nil {
+			// 因为BudgetTokens 必须大于1024
+			if textRequest.MaxTokens < 1280 {
+				textRequest.MaxTokens = 1280
+			}
+
+			// BudgetTokens 为 max_tokens 的 80%
+			textRequest.Thinking = &dto.Thinking{
+				Type:         "enabled",
+				BudgetTokens: int(float64(textRequest.MaxTokens) * model_setting.GetClaudeSettings().ThinkingAdapterBudgetTokensPercentage),
+			}
+			// TODO: 临时处理
+			// https://docs.anthropic.com/en/docs/build-with-claude/extended-thinking#important-considerations-when-using-extended-thinking
+			textRequest.TopP = 0
+			textRequest.Temperature = common.GetPointer[float64](1.0)
+		}
+		textRequest.Model = strings.TrimSuffix(textRequest.Model, "-thinking")
+		relayInfo.UpstreamModelName = textRequest.Model
+	}
+
+	convertedRequest, err := adaptor.ConvertClaudeRequest(c, relayInfo, textRequest)
+	if err != nil {
+		return service.ClaudeErrorWrapperLocal(err, "convert_request_failed", http.StatusInternalServerError)
+	}
+	jsonData, err := json.Marshal(convertedRequest)
+	if common.DebugEnabled {
+		println("requestBody: ", string(jsonData))
+	}
+	if err != nil {
+		return service.ClaudeErrorWrapperLocal(err, "json_marshal_failed", http.StatusInternalServerError)
+	}
+	requestBody = bytes.NewBuffer(jsonData)
+
+	statusCodeMappingStr := c.GetString("status_code_mapping")
+	var httpResp *http.Response
+	resp, err := adaptor.DoRequest(c, relayInfo, requestBody)
+	if err != nil {
+		return service.ClaudeErrorWrapperLocal(err, "do_request_failed", http.StatusInternalServerError)
+	}
+
+	if resp != nil {
+		httpResp = resp.(*http.Response)
+		relayInfo.IsStream = relayInfo.IsStream || strings.HasPrefix(httpResp.Header.Get("Content-Type"), "text/event-stream")
+		if httpResp.StatusCode != http.StatusOK {
+			openaiErr = service.RelayErrorHandler(httpResp, false)
+			// reset status code 重置状态码
+			service.ResetStatusCode(openaiErr, statusCodeMappingStr)
+			return service.OpenAIErrorToClaudeError(openaiErr)
+		}
+	}
+
+	usage, openaiErr := adaptor.DoResponse(c, httpResp, relayInfo)
+	//log.Printf("usage: %v", usage)
+	if openaiErr != nil {
+		// reset status code 重置状态码
+		service.ResetStatusCode(openaiErr, statusCodeMappingStr)
+		return service.OpenAIErrorToClaudeError(openaiErr)
+	}
+	service.PostClaudeConsumeQuota(c, relayInfo, usage.(*dto.Usage), preConsumedQuota, userQuota, priceData, "")
+	return nil
+}
+
+func getClaudePromptTokens(textRequest *dto.ClaudeRequest, info *relaycommon.RelayInfo) (int, error) {
+	var promptTokens int
+	var err error
+	switch info.RelayMode {
+	default:
+		promptTokens, err = service.CountTokenClaudeRequest(*textRequest, info.UpstreamModelName)
+	}
+	info.PromptTokens = promptTokens
+	return promptTokens, err
+}

relay/common/relay_info.go

@@ -15,8 +15,24 @@ import (
 type ThinkingContentInfo struct {
 type ThinkingContentInfo struct {
 	IsFirstThinkingContent  bool
 	IsFirstThinkingContent  bool
 	SendLastThinkingContent bool
 	SendLastThinkingContent bool
+	HasSentThinkingContent  bool
 }
 }
 
 
+const (
+	LastMessageTypeText  = "text"
+	LastMessageTypeTools = "tools"
+)
+
+type ClaudeConvertInfo struct {
+	LastMessagesType string
+	Index            int
+}
+
+const (
+	RelayFormatOpenAI = "openai"
+	RelayFormatClaude = "claude"
+)
+
 type RelayInfo struct {
 type RelayInfo struct {
 	ChannelType       int
 	ChannelType       int
 	ChannelId         int
 	ChannelId         int
@@ -58,7 +74,10 @@ type RelayInfo struct {
 	UserSetting          map[string]interface{}
 	UserSetting          map[string]interface{}
 	UserEmail            string
 	UserEmail            string
 	UserQuota            int
 	UserQuota            int
+	RelayFormat          string
+	SendResponseCount    int
 	ThinkingContentInfo
 	ThinkingContentInfo
+	ClaudeConvertInfo
 }
 }
 
 
 // 定义支持流式选项的通道类型
 // 定义支持流式选项的通道类型
@@ -82,6 +101,16 @@ func GenRelayInfoWs(c *gin.Context, ws *websocket.Conn) *RelayInfo {
 	return info
 	return info
 }
 }
 
 
+func GenRelayInfoClaude(c *gin.Context) *RelayInfo {
+	info := GenRelayInfo(c)
+	info.RelayFormat = RelayFormatClaude
+	info.ShouldIncludeUsage = false
+	info.ClaudeConvertInfo = ClaudeConvertInfo{
+		LastMessagesType: LastMessageTypeText,
+	}
+	return info
+}
+
 func GenRelayInfo(c *gin.Context) *RelayInfo {
 func GenRelayInfo(c *gin.Context) *RelayInfo {
 	channelType := c.GetInt("channel_type")
 	channelType := c.GetInt("channel_type")
 	channelId := c.GetInt("channel_id")
 	channelId := c.GetInt("channel_id")
@@ -123,6 +152,7 @@ func GenRelayInfo(c *gin.Context) *RelayInfo {
 		ApiKey:         strings.TrimPrefix(c.Request.Header.Get("Authorization"), "Bearer "),
 		ApiKey:         strings.TrimPrefix(c.Request.Header.Get("Authorization"), "Bearer "),
 		Organization:   c.GetString("channel_organization"),
 		Organization:   c.GetString("channel_organization"),
 		ChannelSetting: channelSetting,
 		ChannelSetting: channelSetting,
+		RelayFormat:    RelayFormatOpenAI,
 		ThinkingContentInfo: ThinkingContentInfo{
 		ThinkingContentInfo: ThinkingContentInfo{
 			IsFirstThinkingContent:  true,
 			IsFirstThinkingContent:  true,
 			SendLastThinkingContent: false,
 			SendLastThinkingContent: false,

relay/common_handler/rerank.go

+package common_handler
+
+import (
+	"encoding/json"
+	"github.com/gin-gonic/gin"
+	"io"
+	"net/http"
+	"one-api/dto"
+	"one-api/service"
+)
+
+func RerankHandler(c *gin.Context, resp *http.Response) (*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 jinaResp dto.RerankResponse
+	err = json.Unmarshal(responseBody, &jinaResp)
+	if err != nil {
+		return service.OpenAIErrorWrapper(err, "unmarshal_response_body_failed", http.StatusInternalServerError), nil
+	}
+
+	jsonResponse, err := json.Marshal(jinaResp)
+	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, &jinaResp.Usage
+}

relay/constant/api_type.go

@@ -31,6 +31,7 @@ const (
 	APITypeVolcEngine
 	APITypeVolcEngine
 	APITypeBaiduV2
 	APITypeBaiduV2
 	APITypeOpenRouter
 	APITypeOpenRouter
+	APITypeXinference
 	APITypeDummy // this one is only for count, do not add any channel after this
 	APITypeDummy // this one is only for count, do not add any channel after this
 )
 )
 
 
@@ -89,6 +90,8 @@ func ChannelType2APIType(channelType int) (int, bool) {
 		apiType = APITypeBaiduV2
 		apiType = APITypeBaiduV2
 	case common.ChannelTypeOpenRouter:
 	case common.ChannelTypeOpenRouter:
 		apiType = APITypeOpenRouter
 		apiType = APITypeOpenRouter
+	case common.ChannelTypeXinference:
+		apiType = APITypeXinference
 	}
 	}
 	if apiType == -1 {
 	if apiType == -1 {
 		return APITypeOpenAI, false
 		return APITypeOpenAI, false

relay/helper/common.go

@@ -19,6 +19,30 @@ func SetEventStreamHeaders(c *gin.Context) {
 	c.Writer.Header().Set("X-Accel-Buffering", "no")
 	c.Writer.Header().Set("X-Accel-Buffering", "no")
 }
 }
 
 
+func ClaudeData(c *gin.Context, resp dto.ClaudeResponse) error {
+	jsonData, err := json.Marshal(resp)
+	if err != nil {
+		common.SysError("error marshalling stream response: " + err.Error())
+	} else {
+		c.Render(-1, common.CustomEvent{Data: fmt.Sprintf("event: %s\n", resp.Type)})
+		c.Render(-1, common.CustomEvent{Data: "data: " + string(jsonData)})
+	}
+	if flusher, ok := c.Writer.(http.Flusher); ok {
+		flusher.Flush()
+	} else {
+		return errors.New("streaming error: flusher not found")
+	}
+	return nil
+}
+
+func ClaudeChunkData(c *gin.Context, resp dto.ClaudeResponse, data string) {
+	c.Render(-1, common.CustomEvent{Data: fmt.Sprintf("event: %s\n", resp.Type)})
+	c.Render(-1, common.CustomEvent{Data: fmt.Sprintf("data: %s\n", data)})
+	if flusher, ok := c.Writer.(http.Flusher); ok {
+		flusher.Flush()
+	}
+}
+
 func StringData(c *gin.Context, str string) error {
 func StringData(c *gin.Context, str string) error {
 	//str = strings.TrimPrefix(str, "data: ")
 	//str = strings.TrimPrefix(str, "data: ")
 	//str = strings.TrimSuffix(str, "\r")
 	//str = strings.TrimSuffix(str, "\r")

relay/helper/price.go

@@ -16,6 +16,7 @@ type PriceData struct {
 	CacheRatio             float64
 	CacheRatio             float64
 	GroupRatio             float64
 	GroupRatio             float64
 	UsePrice               bool
 	UsePrice               bool
+	CacheCreationRatio     float64
 	ShouldPreConsumedQuota int
 	ShouldPreConsumedQuota int
 }
 }
 
 
@@ -26,6 +27,7 @@ func ModelPriceHelper(c *gin.Context, info *relaycommon.RelayInfo, promptTokens
 	var modelRatio float64
 	var modelRatio float64
 	var completionRatio float64
 	var completionRatio float64
 	var cacheRatio float64
 	var cacheRatio float64
+	var cacheCreationRatio float64
 	if !usePrice {
 	if !usePrice {
 		preConsumedTokens := common.PreConsumedQuota
 		preConsumedTokens := common.PreConsumedQuota
 		if maxTokens != 0 {
 		if maxTokens != 0 {
@@ -42,6 +44,7 @@ func ModelPriceHelper(c *gin.Context, info *relaycommon.RelayInfo, promptTokens
 		}
 		}
 		completionRatio = operation_setting.GetCompletionRatio(info.OriginModelName)
 		completionRatio = operation_setting.GetCompletionRatio(info.OriginModelName)
 		cacheRatio, _ = operation_setting.GetCacheRatio(info.OriginModelName)
 		cacheRatio, _ = operation_setting.GetCacheRatio(info.OriginModelName)
+		cacheCreationRatio, _ = operation_setting.GetCreateCacheRatio(info.OriginModelName)
 		ratio := modelRatio * groupRatio
 		ratio := modelRatio * groupRatio
 		preConsumedQuota = int(float64(preConsumedTokens) * ratio)
 		preConsumedQuota = int(float64(preConsumedTokens) * ratio)
 	} else {
 	} else {
@@ -54,6 +57,7 @@ func ModelPriceHelper(c *gin.Context, info *relaycommon.RelayInfo, promptTokens
 		GroupRatio:             groupRatio,
 		GroupRatio:             groupRatio,
 		UsePrice:               usePrice,
 		UsePrice:               usePrice,
 		CacheRatio:             cacheRatio,
 		CacheRatio:             cacheRatio,
+		CacheCreationRatio:     cacheCreationRatio,
 		ShouldPreConsumedQuota: preConsumedQuota,
 		ShouldPreConsumedQuota: preConsumedQuota,
 	}, nil
 	}, nil
 }
 }

relay/relay-text.go

@@ -160,7 +160,7 @@ func TextHelper(c *gin.Context) (openaiErr *dto.OpenAIErrorWithStatusCode) {
 		}
 		}
 		requestBody = bytes.NewBuffer(body)
 		requestBody = bytes.NewBuffer(body)
 	} else {
 	} else {
-		convertedRequest, err := adaptor.ConvertRequest(c, relayInfo, textRequest)
+		convertedRequest, err := adaptor.ConvertOpenAIRequest(c, relayInfo, textRequest)
 		if err != nil {
 		if err != nil {
 			return service.OpenAIErrorWrapperLocal(err, "convert_request_failed", http.StatusInternalServerError)
 			return service.OpenAIErrorWrapperLocal(err, "convert_request_failed", http.StatusInternalServerError)
 		}
 		}
@@ -168,6 +168,9 @@ func TextHelper(c *gin.Context) (openaiErr *dto.OpenAIErrorWithStatusCode) {
 		if err != nil {
 		if err != nil {
 			return service.OpenAIErrorWrapperLocal(err, "json_marshal_failed", http.StatusInternalServerError)
 			return service.OpenAIErrorWrapperLocal(err, "json_marshal_failed", http.StatusInternalServerError)
 		}
 		}
+		if common.DebugEnabled {
+			println("requestBody: ", string(jsonData))
+		}
 		requestBody = bytes.NewBuffer(jsonData)
 		requestBody = bytes.NewBuffer(jsonData)
 	}
 	}
 
 

relay/relay_adaptor.go

@@ -18,7 +18,6 @@ import (
 	"one-api/relay/channel/mokaai"
 	"one-api/relay/channel/mokaai"
 	"one-api/relay/channel/ollama"
 	"one-api/relay/channel/ollama"
 	"one-api/relay/channel/openai"
 	"one-api/relay/channel/openai"
-	"one-api/relay/channel/openrouter"
 	"one-api/relay/channel/palm"
 	"one-api/relay/channel/palm"
 	"one-api/relay/channel/perplexity"
 	"one-api/relay/channel/perplexity"
 	"one-api/relay/channel/siliconflow"
 	"one-api/relay/channel/siliconflow"
@@ -34,8 +33,6 @@ import (
 
 
 func GetAdaptor(apiType int) channel.Adaptor {
 func GetAdaptor(apiType int) channel.Adaptor {
 	switch apiType {
 	switch apiType {
-	//case constant.APITypeAIProxyLibrary:
-	//	return &aiproxy.Adaptor{}
 	case constant.APITypeAli:
 	case constant.APITypeAli:
 		return &ali.Adaptor{}
 		return &ali.Adaptor{}
 	case constant.APITypeAnthropic:
 	case constant.APITypeAnthropic:
@@ -85,7 +82,9 @@ func GetAdaptor(apiType int) channel.Adaptor {
 	case constant.APITypeBaiduV2:
 	case constant.APITypeBaiduV2:
 		return &baidu_v2.Adaptor{}
 		return &baidu_v2.Adaptor{}
 	case constant.APITypeOpenRouter:
 	case constant.APITypeOpenRouter:
-		return &openrouter.Adaptor{}
+		return &openai.Adaptor{}
+	case constant.APITypeXinference:
+		return &openai.Adaptor{}
 	}
 	}
 	return nil
 	return nil
 }
 }

router/relay-router.go

@@ -35,6 +35,7 @@ func SetRelayRouter(router *gin.Engine) {
 		//http router
 		//http router
 		httpRouter := relayV1Router.Group("")
 		httpRouter := relayV1Router.Group("")
 		httpRouter.Use(middleware.Distribute())
 		httpRouter.Use(middleware.Distribute())
+		httpRouter.POST("/messages", controller.RelayClaude)
 		httpRouter.POST("/completions", controller.Relay)
 		httpRouter.POST("/completions", controller.Relay)
 		httpRouter.POST("/chat/completions", controller.Relay)
 		httpRouter.POST("/chat/completions", controller.Relay)
 		httpRouter.POST("/edits", controller.Relay)
 		httpRouter.POST("/edits", controller.Relay)

service/error.go

@@ -50,6 +50,30 @@ func OpenAIErrorWrapperLocal(err error, code string, statusCode int) *dto.OpenAI
 	return openaiErr
 	return openaiErr
 }
 }
 
 
+func ClaudeErrorWrapper(err error, code string, statusCode int) *dto.ClaudeErrorWithStatusCode {
+	text := err.Error()
+	lowerText := strings.ToLower(text)
+	if strings.Contains(lowerText, "post") || strings.Contains(lowerText, "dial") || strings.Contains(lowerText, "http") {
+		common.SysLog(fmt.Sprintf("error: %s", text))
+		text = "请求上游地址失败"
+	}
+	claudeError := dto.ClaudeError{
+		Message: text,
+		Type:    "new_api_error",
+		//Code:    code,
+	}
+	return &dto.ClaudeErrorWithStatusCode{
+		Error:      claudeError,
+		StatusCode: statusCode,
+	}
+}
+
+func ClaudeErrorWrapperLocal(err error, code string, statusCode int) *dto.ClaudeErrorWithStatusCode {
+	claudeErr := ClaudeErrorWrapper(err, code, statusCode)
+	claudeErr.LocalError = true
+	return claudeErr
+}
+
 func RelayErrorHandler(resp *http.Response, showBodyWhenFail bool) (errWithStatusCode *dto.OpenAIErrorWithStatusCode) {
 func RelayErrorHandler(resp *http.Response, showBodyWhenFail bool) (errWithStatusCode *dto.OpenAIErrorWithStatusCode) {
 	errWithStatusCode = &dto.OpenAIErrorWithStatusCode{
 	errWithStatusCode = &dto.OpenAIErrorWithStatusCode{
 		StatusCode: resp.StatusCode,
 		StatusCode: resp.StatusCode,

service/log_info_generate.go

@@ -53,3 +53,12 @@ func GenerateAudioOtherInfo(ctx *gin.Context, relayInfo *relaycommon.RelayInfo,
 	info["audio_completion_ratio"] = audioCompletionRatio
 	info["audio_completion_ratio"] = audioCompletionRatio
 	return info
 	return info
 }
 }
+
+func GenerateClaudeOtherInfo(ctx *gin.Context, relayInfo *relaycommon.RelayInfo, modelRatio, groupRatio, completionRatio float64,
+	cacheTokens int, cacheRatio float64, cacheCreationTokens int, cacheCreationRatio float64, modelPrice float64) map[string]interface{} {
+	info := GenerateTextOtherInfo(ctx, relayInfo, modelRatio, groupRatio, completionRatio, cacheTokens, cacheRatio, modelPrice)
+	info["claude"] = true
+	info["cache_creation_tokens"] = cacheCreationTokens
+	info["cache_creation_ratio"] = cacheCreationRatio
+	return info
+}

service/quota.go

@@ -194,6 +194,75 @@ func PostWssConsumeQuota(ctx *gin.Context, relayInfo *relaycommon.RelayInfo, mod
 		tokenName, quota, logContent, relayInfo.TokenId, userQuota, int(useTimeSeconds), relayInfo.IsStream, relayInfo.Group, other)
 		tokenName, quota, logContent, relayInfo.TokenId, userQuota, int(useTimeSeconds), relayInfo.IsStream, relayInfo.Group, other)
 }
 }
 
 
+func PostClaudeConsumeQuota(ctx *gin.Context, relayInfo *relaycommon.RelayInfo,
+	usage *dto.Usage, preConsumedQuota int, userQuota int, priceData helper.PriceData, extraContent string) {
+
+	useTimeSeconds := time.Now().Unix() - relayInfo.StartTime.Unix()
+	promptTokens := usage.PromptTokens
+	completionTokens := usage.CompletionTokens
+	modelName := relayInfo.OriginModelName
+
+	tokenName := ctx.GetString("token_name")
+	completionRatio := priceData.CompletionRatio
+	modelRatio := priceData.ModelRatio
+	groupRatio := priceData.GroupRatio
+	modelPrice := priceData.ModelPrice
+
+	cacheRatio := priceData.CacheRatio
+	cacheTokens := usage.PromptTokensDetails.CachedTokens
+
+	cacheCreationRatio := priceData.CacheCreationRatio
+	cacheCreationTokens := usage.PromptTokensDetails.CachedCreationTokens
+
+	calculateQuota := 0.0
+	if !priceData.UsePrice {
+		calculateQuota = float64(promptTokens)
+		calculateQuota += float64(cacheTokens) * cacheRatio
+		calculateQuota += float64(cacheCreationTokens) * cacheCreationRatio
+		calculateQuota += float64(completionTokens) * completionRatio
+		calculateQuota = calculateQuota * groupRatio * modelRatio
+	} else {
+		calculateQuota = modelPrice * common.QuotaPerUnit * groupRatio
+	}
+
+	if modelRatio != 0 && calculateQuota <= 0 {
+		calculateQuota = 1
+	}
+
+	quota := int(calculateQuota)
+
+	totalTokens := promptTokens + completionTokens
+
+	var logContent string
+	// record all the consume log even if quota is 0
+	if totalTokens == 0 {
+		// in this case, must be some error happened
+		// we cannot just return, because we may have to return the pre-consumed quota
+		quota = 0
+		logContent += fmt.Sprintf("（可能是上游出错）")
+		common.LogError(ctx, fmt.Sprintf("total tokens is 0, cannot consume quota, userId %d, channelId %d, "+
+			"tokenId %d, model %s， pre-consumed quota %d", relayInfo.UserId, relayInfo.ChannelId, relayInfo.TokenId, modelName, preConsumedQuota))
+	} else {
+		//if sensitiveResp != nil {
+		//	logContent += fmt.Sprintf("，敏感词：%s", strings.Join(sensitiveResp.SensitiveWords, ", "))
+		//}
+		quotaDelta := quota - preConsumedQuota
+		if quotaDelta != 0 {
+			err := PostConsumeQuota(relayInfo, quotaDelta, preConsumedQuota, true)
+			if err != nil {
+				common.LogError(ctx, "error consuming token remain quota: "+err.Error())
+			}
+		}
+		model.UpdateUserUsedQuotaAndRequestCount(relayInfo.UserId, quota)
+		model.UpdateChannelUsedQuota(relayInfo.ChannelId, quota)
+	}
+
+	other := GenerateClaudeOtherInfo(ctx, relayInfo, modelRatio, groupRatio, completionRatio,
+		cacheTokens, cacheRatio, cacheCreationTokens, cacheCreationRatio, modelPrice)
+	model.RecordConsumeLog(ctx, relayInfo.UserId, relayInfo.ChannelId, promptTokens, completionTokens, modelName,
+		tokenName, quota, logContent, relayInfo.TokenId, userQuota, int(useTimeSeconds), relayInfo.IsStream, relayInfo.Group, other)
+}
+
 func PostAudioConsumeQuota(ctx *gin.Context, relayInfo *relaycommon.RelayInfo,
 func PostAudioConsumeQuota(ctx *gin.Context, relayInfo *relaycommon.RelayInfo,
 	usage *dto.Usage, preConsumedQuota int, userQuota int, priceData helper.PriceData, extraContent string) {
 	usage *dto.Usage, preConsumedQuota int, userQuota int, priceData helper.PriceData, extraContent string) {
 
 

service/token_counter.go

 package service
 package service
 
 
 import (
 import (
+	"encoding/json"
 	"errors"
 	"errors"
 	"fmt"
 	"fmt"
 	"image"
 	"image"
@@ -192,6 +193,110 @@ func CountTokenChatRequest(info *relaycommon.RelayInfo, request dto.GeneralOpenA
 	return tkm, nil
 	return tkm, nil
 }
 }
 
 
+func CountTokenClaudeRequest(request dto.ClaudeRequest, model string) (int, error) {
+	tkm := 0
+
+	// Count tokens in messages
+	msgTokens, err := CountTokenClaudeMessages(request.Messages, model, request.Stream)
+	if err != nil {
+		return 0, err
+	}
+	tkm += msgTokens
+
+	// Count tokens in system message
+	if request.System != "" {
+		systemTokens, err := CountTokenInput(request.System, model)
+		if err != nil {
+			return 0, err
+		}
+		tkm += systemTokens
+	}
+
+	if request.Tools != nil {
+		// check is array
+		if tools, ok := request.Tools.([]any); ok {
+			if len(tools) > 0 {
+				parsedTools, err1 := common.Any2Type[[]dto.Tool](request.Tools)
+				if err1 != nil {
+					return 0, fmt.Errorf("tools: Input should be a valid list: %v", err)
+				}
+				toolTokens, err2 := CountTokenClaudeTools(parsedTools, model)
+				if err2 != nil {
+					return 0, fmt.Errorf("tools: %v", err)
+				}
+				tkm += toolTokens
+			}
+		} else {
+			return 0, errors.New("tools: Input should be a valid list")
+		}
+	}
+
+	return tkm, nil
+}
+
+func CountTokenClaudeMessages(messages []dto.ClaudeMessage, model string, stream bool) (int, error) {
+	tokenEncoder := getTokenEncoder(model)
+	tokenNum := 0
+
+	for _, message := range messages {
+		// Count tokens for role
+		tokenNum += getTokenNum(tokenEncoder, message.Role)
+		if message.IsStringContent() {
+			tokenNum += getTokenNum(tokenEncoder, message.GetStringContent())
+		} else {
+			content, err := message.ParseContent()
+			if err != nil {
+				return 0, err
+			}
+			for _, mediaMessage := range content {
+				switch mediaMessage.Type {
+				case "text":
+					tokenNum += getTokenNum(tokenEncoder, mediaMessage.GetText())
+				case "image":
+					//imageTokenNum, err := getClaudeImageToken(mediaMsg.Source, model, stream)
+					//if err != nil {
+					//	return 0, err
+					//}
+					tokenNum += 1000
+				case "tool_use":
+					tokenNum += getTokenNum(tokenEncoder, mediaMessage.Name)
+					inputJSON, _ := json.Marshal(mediaMessage.Input)
+					tokenNum += getTokenNum(tokenEncoder, string(inputJSON))
+				case "tool_result":
+					contentJSON, _ := json.Marshal(mediaMessage.Content)
+					tokenNum += getTokenNum(tokenEncoder, string(contentJSON))
+				}
+			}
+		}
+	}
+
+	// Add a constant for message formatting (this may need adjustment based on Claude's exact formatting)
+	tokenNum += len(messages) * 2 // Assuming 2 tokens per message for formatting
+
+	return tokenNum, nil
+}
+
+func CountTokenClaudeTools(tools []dto.Tool, model string) (int, error) {
+	tokenEncoder := getTokenEncoder(model)
+	tokenNum := 0
+
+	for _, tool := range tools {
+		tokenNum += getTokenNum(tokenEncoder, tool.Name)
+		tokenNum += getTokenNum(tokenEncoder, tool.Description)
+
+		schemaJSON, err := json.Marshal(tool.InputSchema)
+		if err != nil {
+			return 0, errors.New(fmt.Sprintf("marshal_tool_schema_fail: %s", err.Error()))
+		}
+		tokenNum += getTokenNum(tokenEncoder, string(schemaJSON))
+	}
+
+	// Add a constant for tool formatting (this may need adjustment based on Claude's exact formatting)
+	tokenNum += len(tools) * 3 // Assuming 3 tokens per tool for formatting
+
+	return tokenNum, nil
+}
+
 func CountTokenRealtime(info *relaycommon.RelayInfo, request dto.RealtimeEvent, model string) (int, int, error) {
 func CountTokenRealtime(info *relaycommon.RelayInfo, request dto.RealtimeEvent, model string) (int, int, error) {
 	audioToken := 0
 	audioToken := 0
 	textToken := 0
 	textToken := 0

setting/operation_setting/cache_ratio.go

@@ -7,26 +7,45 @@ import (
 )
 )
 
 
 var defaultCacheRatio = map[string]float64{
 var defaultCacheRatio = map[string]float64{
-	"gpt-4":                        0.5,
-	"o1":                           0.5,
-	"o1-2024-12-17":                0.5,
-	"o1-preview-2024-09-12":        0.5,
-	"o1-preview":                   0.5,
-	"o1-mini-2024-09-12":           0.5,
-	"o1-mini":                      0.5,
-	"gpt-4o-2024-11-20":            0.5,
-	"gpt-4o-2024-08-06":            0.5,
-	"gpt-4o":                       0.5,
-	"gpt-4o-mini-2024-07-18":       0.5,
-	"gpt-4o-mini":                  0.5,
-	"gpt-4o-realtime-preview":      0.5,
-	"gpt-4o-mini-realtime-preview": 0.5,
-	"deepseek-chat":                0.25,
-	"deepseek-reasoner":            0.25,
-	"deepseek-coder":               0.25,
+	"gpt-4":                               0.5,
+	"o1":                                  0.5,
+	"o1-2024-12-17":                       0.5,
+	"o1-preview-2024-09-12":               0.5,
+	"o1-preview":                          0.5,
+	"o1-mini-2024-09-12":                  0.5,
+	"o1-mini":                             0.5,
+	"gpt-4o-2024-11-20":                   0.5,
+	"gpt-4o-2024-08-06":                   0.5,
+	"gpt-4o":                              0.5,
+	"gpt-4o-mini-2024-07-18":              0.5,
+	"gpt-4o-mini":                         0.5,
+	"gpt-4o-realtime-preview":             0.5,
+	"gpt-4o-mini-realtime-preview":        0.5,
+	"deepseek-chat":                       0.25,
+	"deepseek-reasoner":                   0.25,
+	"deepseek-coder":                      0.25,
+	"claude-3-sonnet-20240229":            0.1,
+	"claude-3-opus-20240229":              0.1,
+	"claude-3-haiku-20240307":             0.1,
+	"claude-3-5-haiku-20241022":           0.1,
+	"claude-3-5-sonnet-20240620":          0.1,
+	"claude-3-5-sonnet-20241022":          0.1,
+	"claude-3-7-sonnet-20250219":          0.1,
+	"claude-3-7-sonnet-20250219-thinking": 0.1,
 }
 }
 
 
-var defaultCreateCacheRatio = map[string]float64{}
+var defaultCreateCacheRatio = map[string]float64{
+	"claude-3-sonnet-20240229":            1.25,
+	"claude-3-opus-20240229":              1.25,
+	"claude-3-haiku-20240307":             1.25,
+	"claude-3-5-haiku-20241022":           1.25,
+	"claude-3-5-sonnet-20240620":          1.25,
+	"claude-3-5-sonnet-20241022":          1.25,
+	"claude-3-7-sonnet-20250219":          1.25,
+	"claude-3-7-sonnet-20250219-thinking": 1.25,
+}
+
+//var defaultCreateCacheRatio = map[string]float64{}
 
 
 var cacheRatioMap map[string]float64
 var cacheRatioMap map[string]float64
 var cacheRatioMapMutex sync.RWMutex
 var cacheRatioMapMutex sync.RWMutex
@@ -69,16 +88,10 @@ func GetCacheRatio(name string) (float64, bool) {
 	return ratio, true
 	return ratio, true
 }
 }
 
 
-// DefaultCacheRatio2JSONString converts the default cache ratio map to a JSON string
-func DefaultCacheRatio2JSONString() string {
-	jsonBytes, err := json.Marshal(defaultCacheRatio)
-	if err != nil {
-		common.SysError("error marshalling default cache ratio: " + err.Error())
+func GetCreateCacheRatio(name string) (float64, bool) {
+	ratio, ok := defaultCreateCacheRatio[name]
+	if !ok {
+		return 1.25, false // Default to 1.25 if not found
 	}
 	}
-	return string(jsonBytes)
-}
-
-// GetDefaultCacheRatioMap returns the default cache ratio map
-func GetDefaultCacheRatioMap() map[string]float64 {
-	return defaultCacheRatio
+	return ratio, true
 }
 }

web/src/components/LogsTable.js

@@ -26,8 +26,14 @@ import {
 } from '@douyinfe/semi-ui';
 } from '@douyinfe/semi-ui';
 import { ITEMS_PER_PAGE } from '../constants';
 import { ITEMS_PER_PAGE } from '../constants';
 import {
 import {
-  renderAudioModelPrice, renderGroup,
-  renderModelPrice, renderModelPriceSimple,
+  renderAudioModelPrice,
+  renderClaudeLogContent,
+  renderClaudeModelPrice,
+  renderClaudeModelPriceSimple,
+  renderGroup,
+  renderLogContent,
+  renderModelPrice,
+  renderModelPriceSimple,
   renderNumber,
   renderNumber,
   renderQuota,
   renderQuota,
   stringToColor
   stringToColor
@@ -564,13 +570,23 @@ const LogsTable = () => {
           );
           );
         }
         }
 
 
-        let content = renderModelPriceSimple(
-          other.model_ratio,
-          other.model_price,
-          other.group_ratio,
-          other.cache_tokens || 0,
-          other.cache_ratio || 1.0,
-        );
+        let content = other?.claude
+          ? renderClaudeModelPriceSimple(
+            other.model_ratio,
+            other.model_price,
+            other.group_ratio,
+            other.cache_tokens || 0,
+            other.cache_ratio || 1.0,
+            other.cache_creation_tokens || 0,
+            other.cache_creation_ratio || 1.0,
+          )
+          : renderModelPriceSimple(
+            other.model_ratio,
+            other.model_price,
+            other.group_ratio,
+            other.cache_tokens || 0,
+            other.cache_ratio || 1.0,
+          );
         return (
         return (
             <Paragraph
             <Paragraph
                 ellipsis={{
                 ellipsis={{
@@ -818,10 +834,34 @@ const LogsTable = () => {
           value: other.cache_tokens,
           value: other.cache_tokens,
         });
         });
       }
       }
-      expandDataLocal.push({
-        key: t('日志详情'),
-        value: logs[i].content,
-      });
+      if (other?.cache_creation_tokens > 0) {
+        expandDataLocal.push({
+          key: t('缓存创建 Tokens'),
+          value: other.cache_creation_tokens,
+        });
+      }
+      if (logs[i].type === 2) {
+        expandDataLocal.push({
+          key: t('日志详情'),
+          value: other?.claude
+            ? renderClaudeLogContent(
+              other?.model_ratio,
+              other.completion_ratio,
+              other.model_price,
+              other.group_ratio,
+              other.user_group_ratio,
+              other.cache_ratio || 1.0,
+              other.cache_creation_ratio || 1.0
+            )
+            : renderLogContent(
+              other?.model_ratio,
+              other.completion_ratio,
+              other.model_price,
+              other.group_ratio,
+              other.user_group_ratio
+            ),
+        });
+      }
       if (logs[i].type === 2) {
       if (logs[i].type === 2) {
         let modelMapped = other?.is_model_mapped && other?.upstream_model_name && other?.upstream_model_name !== '';
         let modelMapped = other?.is_model_mapped && other?.upstream_model_name && other?.upstream_model_name !== '';
         if (modelMapped) {
         if (modelMapped) {
@@ -850,6 +890,19 @@ const LogsTable = () => {
             other?.cache_tokens || 0,
             other?.cache_tokens || 0,
             other?.cache_ratio || 1.0,
             other?.cache_ratio || 1.0,
           );
           );
+        } else if (other?.claude) {
+          content = renderClaudeModelPrice(
+            logs[i].prompt_tokens,
+            logs[i].completion_tokens,
+            other.model_ratio,
+            other.model_price,
+            other.completion_ratio,
+            other.group_ratio,
+            other.cache_tokens || 0,
+            other.cache_ratio || 1.0,
+            other.cache_creation_tokens || 0,
+            other.cache_creation_ratio || 1.0,
+          );
         } else {
         } else {
           content = renderModelPrice(
           content = renderModelPrice(
             logs[i].prompt_tokens,
             logs[i].prompt_tokens,

web/src/constants/channel.constants.js

@@ -80,11 +80,12 @@ export const CHANNEL_OPTIONS = [
     label: 'Google PaLM2'
     label: 'Google PaLM2'
   },
   },
   {
   {
-    value: 45,
+    value: 47,
     color: 'blue',
     color: 'blue',
-    label: '字节火山方舟、豆包、DeepSeek通用'
+    label: 'Xinference'
   },
   },
   { value: 25, color: 'green', label: 'Moonshot' },
   { value: 25, color: 'green', label: 'Moonshot' },
+  { value: 20, color: 'green', label: 'OpenRouter' },
   { value: 19, color: 'blue', label: '360 智脑' },
   { value: 19, color: 'blue', label: '360 智脑' },
   { value: 23, color: 'teal', label: '腾讯混元' },
   { value: 23, color: 'teal', label: '腾讯混元' },
   { value: 31, color: 'green', label: '零一万物' },
   { value: 31, color: 'green', label: '零一万物' },
@@ -108,5 +109,10 @@ export const CHANNEL_OPTIONS = [
     value: 44,
     value: 44,
     color: 'purple',
     color: 'purple',
     label: '嵌入模型：MokaAI M3E'
     label: '嵌入模型：MokaAI M3E'
-  }
+  },
+  {
+    value: 45,
+    color: 'blue',
+    label: '字节火山方舟、豆包、DeepSeek通用'
+  },
 ];
 ];

web/src/helpers/render.js

@@ -325,9 +325,8 @@ export function renderModelPrice(
     return (
     return (
       <>
       <>
         <article>
         <article>
-          <p>{i18next.t('提示价格：${{price}} = ${{total}} / 1M tokens', {
+          <p>{i18next.t('提示价格：${{price}} / 1M tokens', {
             price: inputRatioPrice,
             price: inputRatioPrice,
-            total: inputRatioPrice
           })}</p>
           })}</p>
           <p>{i18next.t('补全价格：${{price}} * {{completionRatio}} = ${{total}} / 1M tokens (补全倍率: {{completionRatio}})', {
           <p>{i18next.t('补全价格：${{price}} * {{completionRatio}} = ${{total}} / 1M tokens (补全倍率: {{completionRatio}})', {
             price: inputRatioPrice,
             price: inputRatioPrice,
@@ -445,9 +444,8 @@ export function renderAudioModelPrice(
     return (
     return (
       <>
       <>
         <article>
         <article>
-          <p>{i18next.t('提示价格：${{price}} = ${{total}} / 1M tokens', {
+          <p>{i18next.t('提示价格：${{price}} / 1M tokens', {
             price: inputRatioPrice,
             price: inputRatioPrice,
-            total: inputRatioPrice
           })}</p>
           })}</p>
           <p>{i18next.t('补全价格：${{price}} * {{completionRatio}} = ${{total}} / 1M tokens (补全倍率: {{completionRatio}})', {
           <p>{i18next.t('补全价格：${{price}} * {{completionRatio}} = ${{total}} / 1M tokens (补全倍率: {{completionRatio}})', {
             price: inputRatioPrice,
             price: inputRatioPrice,
@@ -654,3 +652,194 @@ export function stringToColor(str) {
   let i = sum % colors.length;
   let i = sum % colors.length;
   return colors[i];
   return colors[i];
 }
 }
+
+export function renderClaudeModelPrice(
+  inputTokens,
+  completionTokens,
+  modelRatio,
+  modelPrice = -1,
+  completionRatio,
+  groupRatio,
+  cacheTokens = 0,
+  cacheRatio = 1.0,
+  cacheCreationTokens = 0,
+  cacheCreationRatio = 1.0,
+) {
+  const ratioLabel = false ? i18next.t('专属倍率') : i18next.t('分组倍率');
+
+  if (modelPrice !== -1) {
+    return i18next.t('模型价格：${{price}} * {{ratioType}}：{{ratio}} = ${{total}}', {
+      price: modelPrice,
+      ratioType: ratioLabel,
+      ratio: groupRatio,
+      total: modelPrice * groupRatio
+    });
+  } else {
+    if (completionRatio === undefined) {
+      completionRatio = 0;
+    }
+
+    const completionRatioValue = completionRatio || 0;
+    const inputRatioPrice = modelRatio * 2.0;
+    const completionRatioPrice = modelRatio * 2.0 * completionRatioValue;
+    let cacheRatioPrice = (modelRatio * 2.0 * cacheRatio).toFixed(2);
+    let cacheCreationRatioPrice = modelRatio * 2.0 * cacheCreationRatio;
+
+    // Calculate effective input tokens (non-cached + cached with ratio applied + cache creation with ratio applied)
+    const nonCachedTokens = inputTokens;
+    const effectiveInputTokens = nonCachedTokens +
+      (cacheTokens * cacheRatio) +
+      (cacheCreationTokens * cacheCreationRatio);
+
+    let price =
+      (effectiveInputTokens / 1000000) * inputRatioPrice * groupRatio +
+      (completionTokens / 1000000) * completionRatioPrice * groupRatio;
+
+    return (
+      <>
+        <article>
+          <p>{i18next.t('提示价格：${{price}} / 1M tokens', {
+            price: inputRatioPrice,
+          })}</p>
+          <p>{i18next.t('补全价格：${{price}} * {{ratio}} = ${{total}} / 1M tokens', {
+            price: inputRatioPrice,
+            ratio: completionRatio,
+            total: completionRatioPrice
+          })}</p>
+          {cacheTokens > 0 && (
+            <p>{i18next.t('缓存价格：${{price}} * {{ratio}} = ${{total}} / 1M tokens (缓存倍率: {{cacheRatio}})', {
+              price: inputRatioPrice,
+              ratio: cacheRatio,
+              total: cacheRatioPrice,
+              cacheRatio: cacheRatio
+            })}</p>
+          )}
+          {cacheCreationTokens > 0 && (
+            <p>{i18next.t('缓存创建价格：${{price}} * {{ratio}} = ${{total}} / 1M tokens (缓存创建倍率: {{cacheCreationRatio}})', {
+              price: inputRatioPrice,
+              ratio: cacheCreationRatio,
+              total: cacheCreationRatioPrice,
+              cacheCreationRatio: cacheCreationRatio
+            })}</p>
+          )}
+          <p></p>
+          <p>
+            {(cacheTokens > 0 || cacheCreationTokens > 0) ?
+              i18next.t('提示 {{nonCacheInput}} tokens / 1M tokens * ${{price}} + 缓存 {{cacheInput}} tokens / 1M tokens * ${{cachePrice}} + 缓存创建 {{cacheCreationInput}} tokens / 1M tokens * ${{cacheCreationPrice}} + 补全 {{completion}} tokens / 1M tokens * ${{compPrice}} * 分组 {{ratio}} = ${{total}}', {
+                nonCacheInput: nonCachedTokens,
+                cacheInput: cacheTokens,
+                cacheRatio: cacheRatio,
+                cacheCreationInput: cacheCreationTokens,
+                cacheCreationRatio: cacheCreationRatio,
+                cachePrice: cacheRatioPrice,
+                cacheCreationPrice: cacheCreationRatioPrice,
+                price: inputRatioPrice,
+                completion: completionTokens,
+                compPrice: completionRatioPrice,
+                ratio: groupRatio,
+                total: price.toFixed(6)
+              }) :
+              i18next.t('提示 {{input}} tokens / 1M tokens * ${{price}} + 补全 {{completion}} tokens / 1M tokens * ${{compPrice}} * 分组 {{ratio}} = ${{total}}', {
+                input: inputTokens,
+                price: inputRatioPrice,
+                completion: completionTokens,
+                compPrice: completionRatioPrice,
+                ratio: groupRatio,
+                total: price.toFixed(6)
+              })
+            }
+          </p>
+          <p>{i18next.t('仅供参考，以实际扣费为准')}</p>
+        </article>
+      </>
+    );
+  }
+}
+
+export function renderClaudeLogContent(
+  modelRatio,
+  completionRatio,
+  modelPrice = -1,
+  groupRatio,
+  cacheRatio = 1.0,
+  cacheCreationRatio = 1.0,
+) {
+  const ratioLabel = false ? i18next.t('专属倍率') : i18next.t('分组倍率');
+
+  if (modelPrice !== -1) {
+    return i18next.t('模型价格 ${{price}}，{{ratioType}} {{ratio}}', {
+      price: modelPrice,
+      ratioType: ratioLabel,
+      ratio: groupRatio
+    });
+  } else {
+    return i18next.t('模型倍率 {{modelRatio}}，补全倍率 {{completionRatio}}，缓存倍率 {{cacheRatio}}，缓存创建倍率 {{cacheCreationRatio}}，{{ratioType}} {{ratio}}', {
+      modelRatio: modelRatio,
+      completionRatio: completionRatio,
+      cacheRatio: cacheRatio,
+      cacheCreationRatio: cacheCreationRatio,
+      ratioType: ratioLabel,
+      ratio: groupRatio
+    });
+  }
+}
+
+export function renderClaudeModelPriceSimple(
+  modelRatio,
+  modelPrice = -1,
+  groupRatio,
+  cacheTokens = 0,
+  cacheRatio = 1.0,
+  cacheCreationTokens = 0,
+  cacheCreationRatio = 1.0,
+) {
+  const ratioLabel = false ? i18next.t('专属倍率') : i18next.t('分组');
+
+  if (modelPrice !== -1) {
+    return i18next.t('价格：${{price}} * {{ratioType}}：{{ratio}}', {
+      price: modelPrice,
+      ratioType: ratioLabel,
+      ratio: groupRatio
+    });
+  } else {
+    if (cacheTokens !== 0 || cacheCreationTokens !== 0) {
+      return i18next.t('模型: {{ratio}} * {{ratioType}}: {{groupRatio}} * 缓存: {{cacheRatio}}', {
+        ratio: modelRatio,
+        ratioType: ratioLabel,
+        groupRatio: groupRatio,
+        cacheRatio: cacheRatio,
+        cacheCreationRatio: cacheCreationRatio
+      });
+    } else {
+      return i18next.t('模型: {{ratio}} * {{ratioType}}: {{groupRatio}}', {
+        ratio: modelRatio,
+        ratioType: ratioLabel,
+        groupRatio: groupRatio
+      });
+    }
+  }
+}
+
+export function renderLogContent(
+  modelRatio,
+  completionRatio,
+  modelPrice = -1,
+  groupRatio
+) {
+  const ratioLabel = false ? i18next.t('专属倍率') : i18next.t('分组倍率');
+
+  if (modelPrice !== -1) {
+    return i18next.t('模型价格 ${{price}}，{{ratioType}} {{ratio}}', {
+      price: modelPrice,
+      ratioType: ratioLabel,
+      ratio: groupRatio
+    });
+  } else {
+    return i18next.t('模型倍率 {{modelRatio}}，补全倍率 {{completionRatio}}，{{ratioType}} {{ratio}}', {
+      modelRatio: modelRatio,
+      completionRatio: completionRatio,
+      ratioType: ratioLabel,
+      ratio: groupRatio
+    });
+  }
+}