mirrors2/opencatd-open
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

up

Browse Source
This commit is contained in:
c菌
2023-09-16 20:53:50 +08:00
parent f74ba295ee
commit 9e33d22c23
1 changed files with 16 additions and 197 deletions
Download Patch File Download Diff File Expand all files Collapse all files

213
pkg/claude/claude.go
View File

@@ -323,6 +323,22 @@ func TransRsp(c *gin.Context, isStream bool, reader *bufio.Reader) {
dataChan <- string(bytedate)
}
} else {
chatrsp := openai.ChatCompletionStreamResponse{
ID: result.LogID,
Model: result.Model,
Object: "chat.completion",
Created: time.Now().Unix(),
}
choice := openai.ChatCompletionStreamChoice{
Delta: openai.ChatCompletionStreamChoiceDelta{
Role: "assistant",
Content: result.Completion,
},
}
choice.FinishReason = openai.FinishReason(TranslatestopReason(result.StopReason))
chatrsp.Choices = append(chatrsp.Choices, choice)
bytedate, _ := json.Marshal(chatrsp)
dataChan <- string(bytedate)
dataChan <- "[DONE]"
break
}
@@ -359,203 +375,6 @@ func TransRsp(c *gin.Context, isStream bool, reader *bufio.Reader) {
}
}
func TranslateStream(ctx *gin.Context, reader *bufio.Reader, dataChan chan string, stopChan chan bool) {
// dataChan := make(chan string)
// stopChan := make(chan bool)
for {
line, err := reader.ReadString('\n')
if err == nil {
if strings.HasPrefix(line, "data: ") {
var result CompleteResponse
json.NewDecoder(strings.NewReader(line[6:])).Decode(&result)
if result.StopReason == "" {
if result.Completion != "" {
chatrsp := openai.ChatCompletionStreamResponse{
ID: result.LogID,
Model: result.Model,
Object: "chat.completion",
Created: time.Now().Unix(),
}
choice := openai.ChatCompletionStreamChoice{
Delta: openai.ChatCompletionStreamChoiceDelta{
Role: "assistant",
Content: result.Completion,
},
FinishReason: "",
}
chatrsp.Choices = append(chatrsp.Choices, choice)
bytedate, _ := json.Marshal(chatrsp)
dataChan <- string(bytedate)
}
} else {
dataChan <- "data: [DONE]"
break
}
} else {
continue
}
} else {
log.Println("err:", err)
break
}
}
}
func Translate(c *gin.Context, chatreq *openai.ChatCompletionRequest) {
transReq := CompleteRequest{
Model: chatreq.Model,
Temperature: int(chatreq.Temperature),
TopP: int(chatreq.TopP),
Stream: chatreq.Stream,
MaxTokensToSample: chatreq.MaxTokens,
}
var prompt string
for _, msg := range chatreq.Messages {
switch msg.Role {
case "system":
prompt += fmt.Sprintf("\n\nSystem:%s", msg.Content)
case "user":
prompt += fmt.Sprintf("\n\nUser:%s", msg.Content)
case "assistant":
prompt += fmt.Sprintf("\n\nAssistant:%s", msg.Content)
}
}
transReq.Prompt = prompt + "\n\nAssistant:"
key, err := store.SelectKeyCache("anthropic")
if err != nil {
c.JSON(http.StatusInternalServerError, gin.H{
"error": gin.H{
"message": err.Error(),
},
})
return
}
var payload = bytes.NewBuffer(nil)
if err := json.NewEncoder(payload).Encode(transReq); err != nil {
c.JSON(http.StatusInternalServerError, gin.H{
"error": gin.H{
"message": err.Error(),
},
})
return
}
req, _ := http.NewRequest("POST", ClaudeUrl, payload)
req.Header.Add("accept", "application/json")
req.Header.Add("anthropic-version", "2023-06-01")
req.Header.Add("x-api-key", key.Key)
req.Header.Add("content-type", "application/json")
resp, err := http.DefaultClient.Do(req)
if err != nil {
c.JSON(http.StatusInternalServerError, gin.H{
"error": gin.H{
"message": err.Error(),
},
})
return
}
defer resp.Body.Close()
for name, values := range resp.Header {
for _, value := range values {
c.Writer.Header().Add(name, value)
}
}
head := map[string]string{
"Cache-Control": "no-store",
"access-control-allow-origin": "*",
"access-control-allow-credentials": "true",
}
for k, v := range head {
if _, ok := resp.Header[k]; !ok {
c.Writer.Header().Set(k, v)
}
}
resp.Header.Del("content-security-policy")
resp.Header.Del("content-security-policy-report-only")
resp.Header.Del("clear-site-data")
c.Writer.WriteHeader(resp.StatusCode)
writer := bufio.NewWriter(c.Writer)
defer writer.Flush()
reader := bufio.NewReader(resp.Body)
if resp.StatusCode == 200 {
if chatreq.Stream {
contentCh := fetchResponseContent(c, reader)
for content := range contentCh {
writer.WriteString(content)
writer.WriteString("\n\n")
writer.Flush()
}
writer.WriteString("[DONE]")
writer.Flush()
} else {
return
}
}
}
func fetchResponseContent(ctx *gin.Context, responseBody *bufio.Reader) <-chan string {
contentCh := make(chan string)
go func() {
defer close(contentCh)
for {
line, err := responseBody.ReadString('\n')
if err == nil {
lines := strings.Split(line, "")
for _, word := range lines {
ctx.Writer.WriteString(word)
ctx.Writer.Flush()
}
if line == "\n" {
continue
}
if strings.HasPrefix(line, "data:") {
line = strings.TrimSpace(strings.TrimPrefix(line, "data:"))
if strings.HasSuffix(line, "[DONE]") {
break
}
line = strings.TrimSpace(line)
}
dec := json.NewDecoder(strings.NewReader(line))
var data map[string]interface{}
if err := dec.Decode(&data); err == io.EOF {
log.Println("EOF:", err)
break
} else if err != nil {
fmt.Println("Error decoding response:", err)
return
}
if stop_reason, ok := data["stop_reason"].(string); ok {
if stop_reason != "" {
break
} else {
result := data["completion"].(string)
choice := openai.ChatCompletionStreamChoice{
Delta: openai.ChatCompletionStreamChoiceDelta{
Role: "assistant",
Content: result,
},
}
bytedate, _ := json.Marshal(choice)
contentCh <- "data:" + string(bytedate)
}
}
} else {
break
}
}
}()
return contentCh
}
// claude -> openai
func TranslatestopReason(reason string) string {
switch reason {