Add projects
This commit is contained in:
parent
2d3a9ad623
commit
8b607dd700
SSH key fingerprint:
SHA256:GBzT2DXvAuGV9XIV5W3WrzVpjU54FThmxHXdbz95J24
1802 changed files with 503346 additions and 2 deletions
|
|
@ -0,0 +1,403 @@
|
|||
package claude
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"context"
|
||||
"fmt"
|
||||
"strings"
|
||||
"time"
|
||||
|
||||
translatorcommon "github.com/router-for-me/CLIProxyAPI/v7/internal/translator/common"
|
||||
"github.com/tidwall/gjson"
|
||||
"github.com/tidwall/sjson"
|
||||
)
|
||||
|
||||
type interactionsToClaudeStreamState struct {
|
||||
ID string
|
||||
Model string
|
||||
Started bool
|
||||
ActiveBlock bool
|
||||
ActiveBlockType string
|
||||
BlockIndex int
|
||||
SawToolCall bool
|
||||
Completed bool
|
||||
Stopped bool
|
||||
Done bool
|
||||
StepTypes map[int]string
|
||||
ToolNames map[int]string
|
||||
ToolIDs map[int]string
|
||||
ToolSignatures map[int]string
|
||||
}
|
||||
|
||||
func ConvertInteractionsResponseToClaude(_ context.Context, modelName string, originalRequestRawJSON, requestRawJSON, rawJSON []byte, param *any) [][]byte {
|
||||
_ = originalRequestRawJSON
|
||||
_ = requestRawJSON
|
||||
if param == nil {
|
||||
var local any
|
||||
param = &local
|
||||
}
|
||||
if *param == nil {
|
||||
*param = &interactionsToClaudeStreamState{Model: modelName}
|
||||
}
|
||||
st := (*param).(*interactionsToClaudeStreamState)
|
||||
st.Model = firstNonEmpty(st.Model, modelName)
|
||||
st.ensureMaps()
|
||||
return convertInteractionsEventToClaude(modelName, rawJSON, st)
|
||||
}
|
||||
|
||||
func ConvertInteractionsResponseToClaudeNonStream(_ context.Context, modelName string, originalRequestRawJSON, requestRawJSON, rawJSON []byte, _ *any) []byte {
|
||||
_ = originalRequestRawJSON
|
||||
_ = requestRawJSON
|
||||
root := gjson.ParseBytes(rawJSON)
|
||||
interaction := root
|
||||
if nested := root.Get("interaction"); nested.Exists() {
|
||||
interaction = nested
|
||||
}
|
||||
out := []byte(`{"id":"","type":"message","role":"assistant","model":"","content":[],"stop_reason":"end_turn","stop_sequence":null,"usage":{"input_tokens":0,"output_tokens":0}}`)
|
||||
out, _ = sjson.SetBytes(out, "id", firstNonEmpty(interaction.Get("id").String(), root.Get("id").String(), fmt.Sprintf("msg_%d", time.Now().UnixNano())))
|
||||
out, _ = sjson.SetBytes(out, "model", firstNonEmpty(interaction.Get("model").String(), modelName))
|
||||
steps := interaction.Get("steps")
|
||||
if !steps.Exists() {
|
||||
steps = root.Get("steps")
|
||||
}
|
||||
sawToolCall := false
|
||||
var contentBlocks [][]byte
|
||||
steps.ForEach(func(_, step gjson.Result) bool {
|
||||
switch step.Get("type").String() {
|
||||
case "thought":
|
||||
for _, text := range interactionsContentTexts(step.Get("content")) {
|
||||
block := []byte(`{"type":"thinking","thinking":""}`)
|
||||
block, _ = sjson.SetBytes(block, "thinking", text)
|
||||
contentBlocks = append(contentBlocks, block)
|
||||
}
|
||||
case "function_call":
|
||||
sawToolCall = true
|
||||
block := []byte(`{"type":"tool_use","id":"","name":"","input":{}}`)
|
||||
block, _ = sjson.SetBytes(block, "id", interactionsToolID(step))
|
||||
block, _ = sjson.SetBytes(block, "name", step.Get("name").String())
|
||||
if signature := interactionsSignature(step); signature != "" {
|
||||
block, _ = sjson.SetBytes(block, "signature", signature)
|
||||
}
|
||||
args := firstExisting(step, "arguments", "args")
|
||||
if args.Exists() && args.IsObject() {
|
||||
block, _ = sjson.SetRawBytes(block, "input", []byte(args.Raw))
|
||||
}
|
||||
contentBlocks = append(contentBlocks, block)
|
||||
default:
|
||||
for _, text := range interactionsContentTexts(step.Get("content")) {
|
||||
block := []byte(`{"type":"text","text":""}`)
|
||||
block, _ = sjson.SetBytes(block, "text", text)
|
||||
contentBlocks = append(contentBlocks, block)
|
||||
}
|
||||
}
|
||||
return true
|
||||
})
|
||||
if len(contentBlocks) > 0 {
|
||||
out = translatorcommon.SetRawArrayItems(out, "content", contentBlocks)
|
||||
}
|
||||
if sawToolCall {
|
||||
out, _ = sjson.SetBytes(out, "stop_reason", "tool_use")
|
||||
}
|
||||
out = setClaudeUsageFromInteractions(out, "usage", translatorcommon.InteractionsUsage(root))
|
||||
return out
|
||||
}
|
||||
|
||||
func convertInteractionsEventToClaude(modelName string, rawJSON []byte, st *interactionsToClaudeStreamState) [][]byte {
|
||||
payload := interactionsSSEPayload(rawJSON)
|
||||
if len(payload) == 0 {
|
||||
return nil
|
||||
}
|
||||
if bytes.Equal(bytes.TrimSpace(payload), []byte("[DONE]")) {
|
||||
return appendClaudeMessageStop(nil, st)
|
||||
}
|
||||
root := gjson.ParseBytes(payload)
|
||||
if !root.Exists() {
|
||||
return nil
|
||||
}
|
||||
switch root.Get("event_type").String() {
|
||||
case "interaction.created":
|
||||
interaction := root.Get("interaction")
|
||||
st.ID = firstNonEmpty(interaction.Get("id").String(), st.ID)
|
||||
st.Model = firstNonEmpty(interaction.Get("model").String(), st.Model, modelName)
|
||||
return appendClaudeMessageStart(nil, st)
|
||||
case "step.start":
|
||||
return interactionsStepStartToClaude(modelName, root, st)
|
||||
case "step.delta":
|
||||
return interactionsStepDeltaToClaude(modelName, root, st)
|
||||
case "step.stop":
|
||||
return appendClaudeContentBlockStop(nil, st)
|
||||
case "interaction.completed", "finish":
|
||||
return appendClaudeMessageDelta(nil, root, st)
|
||||
case "done":
|
||||
return appendClaudeMessageStop(nil, st)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func interactionsStepStartToClaude(modelName string, root gjson.Result, st *interactionsToClaudeStreamState) [][]byte {
|
||||
out := appendClaudeMessageStart(nil, st)
|
||||
out = appendClaudeContentBlockStop(out, st)
|
||||
index := int(root.Get("index").Int())
|
||||
step := root.Get("step")
|
||||
stepType := step.Get("type").String()
|
||||
st.StepTypes[index] = stepType
|
||||
switch stepType {
|
||||
case "function_call":
|
||||
st.SawToolCall = true
|
||||
st.ToolNames[index] = step.Get("name").String()
|
||||
st.ToolIDs[index] = interactionsToolID(step)
|
||||
st.ToolSignatures[index] = interactionsSignature(step)
|
||||
return appendClaudeToolBlockStart(out, index, st)
|
||||
case "thought":
|
||||
return appendClaudeContentBlockStart(out, "thinking", st)
|
||||
default:
|
||||
_ = modelName
|
||||
return appendClaudeContentBlockStart(out, "text", st)
|
||||
}
|
||||
}
|
||||
|
||||
func interactionsStepDeltaToClaude(modelName string, root gjson.Result, st *interactionsToClaudeStreamState) [][]byte {
|
||||
index := int(root.Get("index").Int())
|
||||
delta := root.Get("delta")
|
||||
switch delta.Get("type").String() {
|
||||
case "thought_summary":
|
||||
out := appendClaudeMessageStart(nil, st)
|
||||
out = ensureClaudeContentBlock(out, "thinking", st)
|
||||
text := firstNonEmpty(delta.Get("content.text").String(), delta.Get("text").String())
|
||||
return appendClaudeContentDelta(out, "thinking_delta", "thinking", text, st)
|
||||
case "thought_signature":
|
||||
if st.ActiveBlock && st.ActiveBlockType == "thinking" {
|
||||
return appendClaudeContentDelta(nil, "signature_delta", "signature", delta.Get("signature").String(), st)
|
||||
}
|
||||
case "arguments_delta":
|
||||
out := appendClaudeMessageStart(nil, st)
|
||||
if !st.ActiveBlock || st.ActiveBlockType != "tool_use" {
|
||||
out = appendClaudeContentBlockStop(out, st)
|
||||
if st.ToolNames[index] == "" {
|
||||
st.ToolNames[index] = root.Get("step.name").String()
|
||||
}
|
||||
if st.ToolIDs[index] == "" {
|
||||
st.ToolIDs[index] = fmt.Sprintf("toolu_%d", index)
|
||||
}
|
||||
out = appendClaudeToolBlockStart(out, index, st)
|
||||
}
|
||||
return appendClaudeContentDelta(out, "input_json_delta", "partial_json", delta.Get("arguments").String(), st)
|
||||
default:
|
||||
_ = modelName
|
||||
out := appendClaudeMessageStart(nil, st)
|
||||
out = ensureClaudeContentBlock(out, "text", st)
|
||||
return appendClaudeContentDelta(out, "text_delta", "text", delta.Get("text").String(), st)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func appendClaudeMessageStart(out [][]byte, st *interactionsToClaudeStreamState) [][]byte {
|
||||
if st.Started {
|
||||
return out
|
||||
}
|
||||
msg := []byte(`{"type":"message_start","message":{"id":"","type":"message","role":"assistant","content":[],"model":"","stop_reason":null,"stop_sequence":null,"usage":{"input_tokens":0,"output_tokens":0}}}`)
|
||||
msg, _ = sjson.SetBytes(msg, "message.id", firstNonEmpty(st.ID, fmt.Sprintf("msg_%d", time.Now().UnixNano())))
|
||||
msg, _ = sjson.SetBytes(msg, "message.model", st.Model)
|
||||
st.Started = true
|
||||
return append(out, translatorcommon.AppendSSEEventBytes(nil, "message_start", msg, 3))
|
||||
}
|
||||
|
||||
func appendClaudeContentBlockStart(out [][]byte, blockType string, st *interactionsToClaudeStreamState) [][]byte {
|
||||
if st.ActiveBlock && st.ActiveBlockType == blockType {
|
||||
return out
|
||||
}
|
||||
out = appendClaudeContentBlockStop(out, st)
|
||||
var block []byte
|
||||
if blockType == "thinking" {
|
||||
block = []byte(`{"type":"content_block_start","index":0,"content_block":{"type":"thinking","thinking":""}}`)
|
||||
} else {
|
||||
block = []byte(`{"type":"content_block_start","index":0,"content_block":{"type":"text","text":""}}`)
|
||||
}
|
||||
block, _ = sjson.SetBytes(block, "index", st.BlockIndex)
|
||||
st.ActiveBlock = true
|
||||
st.ActiveBlockType = blockType
|
||||
return append(out, translatorcommon.AppendSSEEventBytes(nil, "content_block_start", block, 3))
|
||||
}
|
||||
|
||||
func appendClaudeToolBlockStart(out [][]byte, stepIndex int, st *interactionsToClaudeStreamState) [][]byte {
|
||||
out = appendClaudeContentBlockStop(out, st)
|
||||
block := []byte(`{"type":"content_block_start","index":0,"content_block":{"type":"tool_use","id":"","name":"","input":{}}}`)
|
||||
block, _ = sjson.SetBytes(block, "index", st.BlockIndex)
|
||||
block, _ = sjson.SetBytes(block, "content_block.id", firstNonEmpty(st.ToolIDs[stepIndex], fmt.Sprintf("toolu_%d", stepIndex)))
|
||||
block, _ = sjson.SetBytes(block, "content_block.name", st.ToolNames[stepIndex])
|
||||
if signature := st.ToolSignatures[stepIndex]; signature != "" {
|
||||
block, _ = sjson.SetBytes(block, "content_block.signature", signature)
|
||||
}
|
||||
st.ActiveBlock = true
|
||||
st.ActiveBlockType = "tool_use"
|
||||
return append(out, translatorcommon.AppendSSEEventBytes(nil, "content_block_start", block, 3))
|
||||
}
|
||||
|
||||
func ensureClaudeContentBlock(out [][]byte, blockType string, st *interactionsToClaudeStreamState) [][]byte {
|
||||
if st.ActiveBlock && st.ActiveBlockType == blockType {
|
||||
return out
|
||||
}
|
||||
return appendClaudeContentBlockStart(out, blockType, st)
|
||||
}
|
||||
|
||||
func appendClaudeContentDelta(out [][]byte, deltaType, field, value string, st *interactionsToClaudeStreamState) [][]byte {
|
||||
if value == "" && deltaType != "input_json_delta" {
|
||||
return out
|
||||
}
|
||||
delta := []byte(`{"type":"content_block_delta","index":0,"delta":{"type":""}}`)
|
||||
delta, _ = sjson.SetBytes(delta, "index", st.BlockIndex)
|
||||
delta, _ = sjson.SetBytes(delta, "delta.type", deltaType)
|
||||
delta, _ = sjson.SetBytes(delta, "delta."+field, value)
|
||||
return append(out, translatorcommon.AppendSSEEventBytes(nil, "content_block_delta", delta, 3))
|
||||
}
|
||||
|
||||
func appendClaudeContentBlockStop(out [][]byte, st *interactionsToClaudeStreamState) [][]byte {
|
||||
if !st.ActiveBlock {
|
||||
return out
|
||||
}
|
||||
stop := []byte(`{"type":"content_block_stop","index":0}`)
|
||||
stop, _ = sjson.SetBytes(stop, "index", st.BlockIndex)
|
||||
out = append(out, translatorcommon.AppendSSEEventBytes(nil, "content_block_stop", stop, 3))
|
||||
st.ActiveBlock = false
|
||||
st.ActiveBlockType = ""
|
||||
st.BlockIndex++
|
||||
return out
|
||||
}
|
||||
|
||||
func appendClaudeMessageDelta(out [][]byte, root gjson.Result, st *interactionsToClaudeStreamState) [][]byte {
|
||||
if st.Completed {
|
||||
return out
|
||||
}
|
||||
out = appendClaudeMessageStart(out, st)
|
||||
out = appendClaudeContentBlockStop(out, st)
|
||||
payload := []byte(`{"type":"message_delta","delta":{"stop_reason":"end_turn","stop_sequence":null},"usage":{"input_tokens":0,"output_tokens":0}}`)
|
||||
if st.SawToolCall {
|
||||
payload, _ = sjson.SetBytes(payload, "delta.stop_reason", "tool_use")
|
||||
}
|
||||
payload = setClaudeUsageFromInteractions(payload, "usage", translatorcommon.InteractionsUsage(root))
|
||||
out = append(out, translatorcommon.AppendSSEEventBytes(nil, "message_delta", payload, 3))
|
||||
st.Completed = true
|
||||
return out
|
||||
}
|
||||
|
||||
func appendClaudeMessageStop(out [][]byte, st *interactionsToClaudeStreamState) [][]byte {
|
||||
if st.Done {
|
||||
return out
|
||||
}
|
||||
out = appendClaudeContentBlockStop(out, st)
|
||||
if !st.Completed {
|
||||
out = appendClaudeMessageDelta(out, gjson.Result{}, st)
|
||||
}
|
||||
if !st.Stopped {
|
||||
out = append(out, translatorcommon.AppendSSEEventString(nil, "message_stop", `{"type":"message_stop"}`, 3))
|
||||
st.Stopped = true
|
||||
}
|
||||
st.Done = true
|
||||
return out
|
||||
}
|
||||
|
||||
func setClaudeUsageFromInteractions(out []byte, path string, usage gjson.Result) []byte {
|
||||
if !usage.Exists() {
|
||||
return out
|
||||
}
|
||||
if v, ok := firstUsageInt(usage, "input_tokens", "total_input_tokens"); ok {
|
||||
out, _ = sjson.SetBytes(out, path+".input_tokens", v)
|
||||
}
|
||||
if v, ok := firstUsageInt(usage, "output_tokens", "total_output_tokens"); ok {
|
||||
out, _ = sjson.SetBytes(out, path+".output_tokens", v)
|
||||
}
|
||||
return out
|
||||
}
|
||||
|
||||
func interactionsSSEPayload(rawJSON []byte) []byte {
|
||||
trimmed := bytes.TrimSpace(rawJSON)
|
||||
if len(trimmed) == 0 || bytes.Equal(trimmed, []byte("[DONE]")) {
|
||||
return trimmed
|
||||
}
|
||||
if bytes.HasPrefix(trimmed, []byte("data:")) {
|
||||
return bytes.TrimSpace(trimmed[len("data:"):])
|
||||
}
|
||||
var dataLines [][]byte
|
||||
for _, line := range bytes.Split(trimmed, []byte("\n")) {
|
||||
line = bytes.TrimSpace(line)
|
||||
if bytes.HasPrefix(line, []byte("data:")) {
|
||||
dataLines = append(dataLines, bytes.TrimSpace(line[len("data:"):]))
|
||||
}
|
||||
}
|
||||
if len(dataLines) > 0 {
|
||||
return bytes.Join(dataLines, []byte("\n"))
|
||||
}
|
||||
return trimmed
|
||||
}
|
||||
|
||||
func interactionsContentTexts(content gjson.Result) []string {
|
||||
if !content.Exists() {
|
||||
return nil
|
||||
}
|
||||
if content.Type == gjson.String {
|
||||
return []string{content.String()}
|
||||
}
|
||||
var out []string
|
||||
content.ForEach(func(_, part gjson.Result) bool {
|
||||
if text := firstNonEmpty(part.Get("text").String(), part.Get("content.text").String()); text != "" {
|
||||
out = append(out, text)
|
||||
}
|
||||
return true
|
||||
})
|
||||
return out
|
||||
}
|
||||
|
||||
func interactionsToolID(root gjson.Result) string {
|
||||
return firstNonEmpty(root.Get("call_id").String(), root.Get("id").String(), root.Get("tool_use_id").String(), "toolu_interactions")
|
||||
}
|
||||
|
||||
func interactionsSignature(root gjson.Result) string {
|
||||
return firstNonEmpty(
|
||||
root.Get("signature").String(),
|
||||
root.Get("thought_signature").String(),
|
||||
root.Get("thoughtSignature").String(),
|
||||
root.Get("extra_content.google.thought_signature").String(),
|
||||
)
|
||||
}
|
||||
|
||||
func firstExisting(root gjson.Result, paths ...string) gjson.Result {
|
||||
for _, path := range paths {
|
||||
if value := root.Get(path); value.Exists() {
|
||||
return value
|
||||
}
|
||||
}
|
||||
return gjson.Result{}
|
||||
}
|
||||
|
||||
func firstUsageInt(root gjson.Result, paths ...string) (int64, bool) {
|
||||
for _, path := range paths {
|
||||
if value := root.Get(path); value.Exists() {
|
||||
return value.Int(), true
|
||||
}
|
||||
}
|
||||
return 0, false
|
||||
}
|
||||
|
||||
func firstNonEmpty(values ...string) string {
|
||||
for _, value := range values {
|
||||
if strings.TrimSpace(value) != "" {
|
||||
return value
|
||||
}
|
||||
}
|
||||
return ""
|
||||
}
|
||||
|
||||
func (st *interactionsToClaudeStreamState) ensureMaps() {
|
||||
if st.StepTypes == nil {
|
||||
st.StepTypes = make(map[int]string)
|
||||
}
|
||||
if st.ToolNames == nil {
|
||||
st.ToolNames = make(map[int]string)
|
||||
}
|
||||
if st.ToolIDs == nil {
|
||||
st.ToolIDs = make(map[int]string)
|
||||
}
|
||||
if st.ToolSignatures == nil {
|
||||
st.ToolSignatures = make(map[int]string)
|
||||
}
|
||||
}
|
||||
Loading…
Reference in a new issue