461 lines
16 KiB
Go
461 lines
16 KiB
Go
package interactions
|
|
|
|
import (
|
|
"fmt"
|
|
"strings"
|
|
|
|
"github.com/router-for-me/CLIProxyAPI/v7/internal/thinking"
|
|
translatorcommon "github.com/router-for-me/CLIProxyAPI/v7/internal/translator/common"
|
|
"github.com/router-for-me/CLIProxyAPI/v7/internal/util"
|
|
"github.com/tidwall/gjson"
|
|
"github.com/tidwall/sjson"
|
|
)
|
|
|
|
func ConvertInteractionsRequestToClaude(modelName string, inputRawJSON []byte, stream bool) []byte {
|
|
root := gjson.ParseBytes(inputRawJSON)
|
|
out := []byte(`{"model":"","max_tokens":32000,"messages":[]}`)
|
|
out, _ = sjson.SetBytes(out, "model", modelName)
|
|
if stream || root.Get("stream").Bool() {
|
|
out, _ = sjson.SetBytes(out, "stream", true)
|
|
}
|
|
out = copyInteractionsSystemToClaude(out, root)
|
|
out = copyInteractionsGenerationConfigToClaude(out, root)
|
|
messageAccumulator := translatorcommon.NewClaudeMessageAccumulator(int(root.Get("input.#").Int()))
|
|
appendInteractionsInputToClaudeMessages(messageAccumulator, root.Get("input"))
|
|
out = translatorcommon.SetRawArrayItems(out, "messages", messageAccumulator.Messages())
|
|
out = copyInteractionsToolsToClaude(out, root)
|
|
return out
|
|
}
|
|
|
|
func copyInteractionsSystemToClaude(out []byte, root gjson.Result) []byte {
|
|
sys := root.Get("system_instruction")
|
|
if !sys.Exists() {
|
|
sys = root.Get("systemInstruction")
|
|
}
|
|
text := interactionsClaudeText(sys)
|
|
if text == "" {
|
|
return out
|
|
}
|
|
out, _ = sjson.SetBytes(out, "system", text)
|
|
return out
|
|
}
|
|
|
|
func copyInteractionsGenerationConfigToClaude(out []byte, root gjson.Result) []byte {
|
|
cfg := root.Get("generation_config")
|
|
if !cfg.Exists() {
|
|
cfg = root.Get("generationConfig")
|
|
}
|
|
if cfg.Exists() {
|
|
out = copyJSONField(out, cfg, "max_output_tokens", "max_tokens")
|
|
out = copyJSONField(out, cfg, "maxOutputTokens", "max_tokens")
|
|
out = copyJSONField(out, cfg, "top_p", "top_p")
|
|
out = copyJSONField(out, cfg, "topP", "top_p")
|
|
out = copyJSONField(out, cfg, "temperature", "temperature")
|
|
out = copyJSONField(out, cfg, "stop_sequences", "stop_sequences")
|
|
out = copyJSONField(out, cfg, "stopSequences", "stop_sequences")
|
|
out = copyInteractionsThinkingConfigToClaude(out, cfg)
|
|
out = copyInteractionsToolChoiceToClaude(out, cfg.Get("tool_choice"))
|
|
out = copyInteractionsToolChoiceToClaude(out, cfg.Get("toolChoice"))
|
|
}
|
|
out = copyInteractionsReasoningToClaude(out, root.Get("reasoning"))
|
|
out = copyInteractionsToolChoiceToClaude(out, root.Get("tool_choice"))
|
|
out = copyInteractionsToolChoiceToClaude(out, root.Get("toolChoice"))
|
|
return out
|
|
}
|
|
|
|
func copyJSONField(out []byte, root gjson.Result, from, to string) []byte {
|
|
value := root.Get(from)
|
|
if !value.Exists() {
|
|
return out
|
|
}
|
|
out, _ = sjson.SetRawBytes(out, to, []byte(value.Raw))
|
|
return out
|
|
}
|
|
|
|
func copyInteractionsThinkingConfigToClaude(out []byte, cfg gjson.Result) []byte {
|
|
level := firstClaudeInteractionsExisting(cfg, "thinking_level", "thinkingLevel", "reasoning.effort")
|
|
if !level.Exists() {
|
|
return out
|
|
}
|
|
return setClaudeThinkingFromLevel(out, level.String())
|
|
}
|
|
|
|
func copyInteractionsReasoningToClaude(out []byte, reasoning gjson.Result) []byte {
|
|
if !reasoning.Exists() {
|
|
return out
|
|
}
|
|
if effort := reasoning.Get("effort"); effort.Exists() {
|
|
return setClaudeThinkingFromLevel(out, effort.String())
|
|
}
|
|
if level := reasoning.Get("thinking_level"); level.Exists() {
|
|
return setClaudeThinkingFromLevel(out, level.String())
|
|
}
|
|
return out
|
|
}
|
|
|
|
func setClaudeThinkingFromLevel(out []byte, level string) []byte {
|
|
normalized := strings.ToLower(strings.TrimSpace(level))
|
|
if normalized == "" {
|
|
return out
|
|
}
|
|
switch normalized {
|
|
case "none", "disabled", "off", "false":
|
|
out, _ = sjson.SetBytes(out, "thinking.type", "disabled")
|
|
out, _ = sjson.DeleteBytes(out, "thinking.budget_tokens")
|
|
return out
|
|
case "auto", "adaptive":
|
|
out, _ = sjson.SetBytes(out, "thinking.type", "adaptive")
|
|
out, _ = sjson.DeleteBytes(out, "thinking.budget_tokens")
|
|
return out
|
|
}
|
|
if budget, ok := thinking.ConvertLevelToBudget(normalized); ok {
|
|
switch {
|
|
case budget == 0:
|
|
out, _ = sjson.SetBytes(out, "thinking.type", "disabled")
|
|
case budget < 0:
|
|
out, _ = sjson.SetBytes(out, "thinking.type", "enabled")
|
|
default:
|
|
out, _ = sjson.SetBytes(out, "thinking.type", "enabled")
|
|
out, _ = sjson.SetBytes(out, "thinking.budget_tokens", budget)
|
|
}
|
|
return out
|
|
}
|
|
out, _ = sjson.SetBytes(out, "thinking.type", "adaptive")
|
|
out, _ = sjson.SetBytes(out, "output_config.effort", normalized)
|
|
return out
|
|
}
|
|
|
|
func appendInteractionsInputToClaudeMessages(accumulator *translatorcommon.ClaudeMessageAccumulator, input gjson.Result) {
|
|
if !input.Exists() {
|
|
return
|
|
}
|
|
if input.Type == gjson.String {
|
|
step := []byte(`{"type":"user_input","content":[{"type":"text","text":""}]}`)
|
|
step, _ = sjson.SetBytes(step, "content.0.text", input.String())
|
|
appendInteractionsStepToClaude(accumulator, gjson.ParseBytes(step), "user")
|
|
return
|
|
}
|
|
if input.IsObject() {
|
|
appendInteractionsInputItemToClaude(accumulator, input)
|
|
return
|
|
}
|
|
input.ForEach(func(_, step gjson.Result) bool {
|
|
appendInteractionsInputItemToClaude(accumulator, step)
|
|
return true
|
|
})
|
|
}
|
|
|
|
func appendInteractionsInputItemToClaude(accumulator *translatorcommon.ClaudeMessageAccumulator, step gjson.Result) {
|
|
if step.Get("steps").IsArray() {
|
|
defaultRole := "user"
|
|
if role := step.Get("role").String(); role == "model" || role == "assistant" {
|
|
defaultRole = "assistant"
|
|
}
|
|
step.Get("steps").ForEach(func(_, nestedStep gjson.Result) bool {
|
|
appendInteractionsStepToClaude(accumulator, nestedStep, defaultRole)
|
|
return true
|
|
})
|
|
return
|
|
}
|
|
if step.Get("parts").Exists() {
|
|
wrapped := []byte(`{"type":"user_input","content":[]}`)
|
|
if role := step.Get("role").String(); role == "model" || role == "assistant" {
|
|
wrapped, _ = sjson.SetBytes(wrapped, "type", "model_output")
|
|
}
|
|
wrapped, _ = sjson.SetRawBytes(wrapped, "content", []byte(step.Get("parts").Raw))
|
|
appendInteractionsStepToClaude(accumulator, gjson.ParseBytes(wrapped), "user")
|
|
return
|
|
}
|
|
stepType := step.Get("type").String()
|
|
switch stepType {
|
|
case "function_call":
|
|
appendInteractionsFunctionCallToClaude(accumulator, step)
|
|
case "function_result":
|
|
appendInteractionsFunctionResultToClaude(accumulator, step)
|
|
case "model_output", "thought":
|
|
appendInteractionsStepToClaude(accumulator, step, "assistant")
|
|
default:
|
|
appendInteractionsStepToClaude(accumulator, step, "user")
|
|
}
|
|
}
|
|
|
|
func appendInteractionsStepToClaude(accumulator *translatorcommon.ClaudeMessageAccumulator, step gjson.Result, defaultRole string) {
|
|
role := defaultRole
|
|
if stepRole := step.Get("role").String(); stepRole == "user" || stepRole == "assistant" {
|
|
role = stepRole
|
|
}
|
|
contentItems := make([][]byte, 0, 4)
|
|
stepContent := step.Get("content")
|
|
if stepContent.Type == gjson.String {
|
|
part := []byte(`{"type":"text","text":""}`)
|
|
part, _ = sjson.SetBytes(part, "text", stepContent.String())
|
|
contentItems = append(contentItems, part)
|
|
} else if stepContent.IsArray() {
|
|
stepContent.ForEach(func(_, part gjson.Result) bool {
|
|
if converted := interactionsContentToClaude(part, role); len(converted) > 0 {
|
|
contentItems = append(contentItems, converted)
|
|
}
|
|
return true
|
|
})
|
|
} else if text := step.Get("text"); text.Exists() {
|
|
part := []byte(`{"type":"text","text":""}`)
|
|
part, _ = sjson.SetBytes(part, "text", text.String())
|
|
contentItems = append(contentItems, part)
|
|
}
|
|
if len(contentItems) == 0 {
|
|
return
|
|
}
|
|
msg := []byte(`{"role":"","content":[]}`)
|
|
msg, _ = sjson.SetBytes(msg, "role", role)
|
|
msg, _ = sjson.SetRawBytes(msg, "content", translatorcommon.JoinRawArray(contentItems))
|
|
accumulator.Append(msg)
|
|
}
|
|
|
|
func interactionsContentToClaude(part gjson.Result, role string) []byte {
|
|
partType := part.Get("type").String()
|
|
if partType == "" && part.Get("text").Exists() {
|
|
partType = "text"
|
|
}
|
|
switch partType {
|
|
case "text":
|
|
textPart := []byte(`{"type":"text","text":""}`)
|
|
textPart, _ = sjson.SetBytes(textPart, "text", part.Get("text").String())
|
|
return textPart
|
|
case "thinking", "reasoning":
|
|
if role != "assistant" {
|
|
return nil
|
|
}
|
|
thinkingPart := []byte(`{"type":"thinking","thinking":""}`)
|
|
thinkingPart, _ = sjson.SetBytes(thinkingPart, "thinking", interactionsClaudeText(part))
|
|
return thinkingPart
|
|
case "image":
|
|
imagePart, _ := interactionsClaudeMediaPart(part, "image")
|
|
return imagePart
|
|
case "document", "file":
|
|
documentPart, _ := interactionsClaudeMediaPart(part, "document")
|
|
return documentPart
|
|
default:
|
|
if text := interactionsClaudeText(part); text != "" {
|
|
textPart := []byte(`{"type":"text","text":""}`)
|
|
textPart, _ = sjson.SetBytes(textPart, "text", text)
|
|
return textPart
|
|
}
|
|
if part.Get("data").String() != "" || part.Get("file_data").String() != "" {
|
|
textPart := []byte(`{"type":"text","text":""}`)
|
|
textPart, _ = sjson.SetBytes(textPart, "text", fmt.Sprintf("[%s content omitted]", partType))
|
|
return textPart
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func appendInteractionsFunctionCallToClaude(accumulator *translatorcommon.ClaudeMessageAccumulator, step gjson.Result) {
|
|
toolUse := []byte(`{"type":"tool_use","id":"","name":"","input":{}}`)
|
|
toolUse, _ = sjson.SetBytes(toolUse, "id", interactionsClaudeToolID(step))
|
|
toolUse, _ = sjson.SetBytes(toolUse, "name", step.Get("name").String())
|
|
args := step.Get("arguments")
|
|
if !args.Exists() {
|
|
args = step.Get("args")
|
|
}
|
|
if args.Exists() && args.IsObject() {
|
|
toolUse, _ = sjson.SetRawBytes(toolUse, "input", []byte(args.Raw))
|
|
}
|
|
msg := []byte(`{"role":"assistant","content":[]}`)
|
|
msg, _ = sjson.SetRawBytes(msg, "content", translatorcommon.JoinRawArray([][]byte{toolUse}))
|
|
accumulator.Append(msg)
|
|
}
|
|
|
|
func appendInteractionsFunctionResultToClaude(accumulator *translatorcommon.ClaudeMessageAccumulator, step gjson.Result) {
|
|
toolResult := []byte(`{"type":"tool_result","tool_use_id":"","content":""}`)
|
|
toolResult, _ = sjson.SetBytes(toolResult, "tool_use_id", interactionsClaudeToolID(step))
|
|
result := step.Get("result")
|
|
if !result.Exists() {
|
|
result = step.Get("output")
|
|
}
|
|
switch {
|
|
case result.IsArray():
|
|
contentItems := make([][]byte, 0, 4)
|
|
result.ForEach(func(_, part gjson.Result) bool {
|
|
if converted := interactionsContentToClaude(part, "user"); len(converted) > 0 {
|
|
contentItems = append(contentItems, converted)
|
|
}
|
|
return true
|
|
})
|
|
toolResult, _ = sjson.SetRawBytes(toolResult, "content", translatorcommon.JoinRawArray(contentItems))
|
|
case result.Exists() && result.Raw != "":
|
|
toolResult, _ = sjson.SetBytes(toolResult, "content", result.Raw)
|
|
default:
|
|
toolResult, _ = sjson.SetBytes(toolResult, "content", "")
|
|
}
|
|
msg := []byte(`{"role":"user","content":[]}`)
|
|
msg, _ = sjson.SetRawBytes(msg, "content", translatorcommon.JoinRawArray([][]byte{toolResult}))
|
|
accumulator.Append(msg)
|
|
}
|
|
|
|
func copyInteractionsToolsToClaude(out []byte, root gjson.Result) []byte {
|
|
tools := root.Get("tools")
|
|
if !tools.Exists() || !tools.IsArray() {
|
|
return out
|
|
}
|
|
var toolItems [][]byte
|
|
tools.ForEach(func(_, tool gjson.Result) bool {
|
|
if tool.Get("function_declarations").IsArray() {
|
|
tool.Get("function_declarations").ForEach(func(_, decl gjson.Result) bool {
|
|
if converted := interactionsClaudeTool(decl); len(converted) > 0 {
|
|
toolItems = append(toolItems, converted)
|
|
}
|
|
return true
|
|
})
|
|
return true
|
|
}
|
|
if tool.Get("functionDeclarations").IsArray() {
|
|
tool.Get("functionDeclarations").ForEach(func(_, decl gjson.Result) bool {
|
|
if converted := interactionsClaudeTool(decl); len(converted) > 0 {
|
|
toolItems = append(toolItems, converted)
|
|
}
|
|
return true
|
|
})
|
|
return true
|
|
}
|
|
if converted := interactionsClaudeTool(tool); len(converted) > 0 {
|
|
toolItems = append(toolItems, converted)
|
|
}
|
|
return true
|
|
})
|
|
if len(toolItems) > 0 {
|
|
out, _ = sjson.SetRawBytes(out, "tools", translatorcommon.JoinRawArray(toolItems))
|
|
}
|
|
return out
|
|
}
|
|
|
|
func interactionsClaudeTool(tool gjson.Result) []byte {
|
|
name := tool.Get("name").String()
|
|
if name == "" {
|
|
name = tool.Get("function.name").String()
|
|
}
|
|
if name == "" {
|
|
return nil
|
|
}
|
|
converted := []byte(`{"name":"","input_schema":{}}`)
|
|
converted, _ = sjson.SetBytes(converted, "name", name)
|
|
if desc := tool.Get("description"); desc.Exists() {
|
|
converted, _ = sjson.SetBytes(converted, "description", desc.String())
|
|
} else if desc := tool.Get("function.description"); desc.Exists() {
|
|
converted, _ = sjson.SetBytes(converted, "description", desc.String())
|
|
}
|
|
params := firstClaudeInteractionsExisting(tool, "parameters", "parametersJsonSchema", "parameters_json_schema", "input_schema")
|
|
if params.Exists() && params.IsObject() {
|
|
converted, _ = sjson.SetRawBytes(converted, "input_schema", []byte(params.Raw))
|
|
}
|
|
return converted
|
|
}
|
|
|
|
func copyInteractionsToolChoiceToClaude(out []byte, toolChoice gjson.Result) []byte {
|
|
if !toolChoice.Exists() {
|
|
return out
|
|
}
|
|
switch toolChoice.Type {
|
|
case gjson.String:
|
|
switch strings.ToLower(strings.TrimSpace(toolChoice.String())) {
|
|
case "auto":
|
|
out, _ = sjson.SetRawBytes(out, "tool_choice", []byte(`{"type":"auto"}`))
|
|
case "required", "any":
|
|
out, _ = sjson.SetRawBytes(out, "tool_choice", []byte(`{"type":"any"}`))
|
|
}
|
|
case gjson.JSON:
|
|
toolType := strings.ToLower(strings.TrimSpace(toolChoice.Get("type").String()))
|
|
switch toolType {
|
|
case "auto":
|
|
out, _ = sjson.SetRawBytes(out, "tool_choice", []byte(`{"type":"auto"}`))
|
|
case "required", "any":
|
|
out, _ = sjson.SetRawBytes(out, "tool_choice", []byte(`{"type":"any"}`))
|
|
case "function", "tool":
|
|
name := toolChoice.Get("name").String()
|
|
if name == "" {
|
|
name = toolChoice.Get("function.name").String()
|
|
}
|
|
if name != "" {
|
|
choice := []byte(`{"type":"tool","name":""}`)
|
|
choice, _ = sjson.SetBytes(choice, "name", name)
|
|
out, _ = sjson.SetRawBytes(out, "tool_choice", choice)
|
|
}
|
|
}
|
|
}
|
|
return out
|
|
}
|
|
|
|
func interactionsClaudeToolID(step gjson.Result) string {
|
|
for _, path := range []string{"call_id", "id", "tool_use_id"} {
|
|
if value := step.Get(path).String(); value != "" {
|
|
return util.SanitizeClaudeToolID(value)
|
|
}
|
|
}
|
|
if name := step.Get("name").String(); name != "" {
|
|
return util.SanitizeClaudeToolID("toolu_" + name)
|
|
}
|
|
return "toolu_interactions"
|
|
}
|
|
|
|
func interactionsClaudeText(value gjson.Result) string {
|
|
if !value.Exists() {
|
|
return ""
|
|
}
|
|
if value.Type == gjson.String {
|
|
return value.String()
|
|
}
|
|
if text := value.Get("text"); text.Exists() {
|
|
return text.String()
|
|
}
|
|
if thinking := value.Get("thinking"); thinking.Exists() {
|
|
return thinking.String()
|
|
}
|
|
if content := value.Get("content"); content.Exists() {
|
|
return interactionsClaudeText(content)
|
|
}
|
|
if parts := value.Get("parts"); parts.Exists() && parts.IsArray() {
|
|
var builder strings.Builder
|
|
parts.ForEach(func(_, part gjson.Result) bool {
|
|
text := interactionsClaudeText(part)
|
|
if text == "" {
|
|
return true
|
|
}
|
|
if builder.Len() > 0 {
|
|
builder.WriteByte('\n')
|
|
}
|
|
builder.WriteString(text)
|
|
return true
|
|
})
|
|
return builder.String()
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func interactionsClaudeMediaPart(part gjson.Result, claudeType string) ([]byte, bool) {
|
|
mimeType := firstClaudeInteractionsExisting(part, "mime_type", "mimeType", "media_type", "mediaType").String()
|
|
data := firstClaudeInteractionsExisting(part, "data", "file_data", "fileData").String()
|
|
if source := part.Get("source"); source.Exists() {
|
|
if mimeType == "" {
|
|
mimeType = source.Get("media_type").String()
|
|
}
|
|
if data == "" {
|
|
data = source.Get("data").String()
|
|
}
|
|
}
|
|
if mimeType == "" || data == "" {
|
|
return nil, false
|
|
}
|
|
out := []byte(`{"type":"","source":{"type":"base64","media_type":"","data":""}}`)
|
|
out, _ = sjson.SetBytes(out, "type", claudeType)
|
|
out, _ = sjson.SetBytes(out, "source.media_type", mimeType)
|
|
out, _ = sjson.SetBytes(out, "source.data", data)
|
|
return out, true
|
|
}
|
|
|
|
func firstClaudeInteractionsExisting(root gjson.Result, paths ...string) gjson.Result {
|
|
for _, path := range paths {
|
|
if value := root.Get(path); value.Exists() {
|
|
return value
|
|
}
|
|
}
|
|
return gjson.Result{}
|
|
}
|