Something went wrong. Try again.
sloproxy
Something went wrong. Try again.
35 kB · 958 lines
Go
at main
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959package executor
import ( "context" "io" "net/http" "net/http/httptest" "strings" "testing"
"github.com/gin-gonic/gin" "github.com/router-for-me/CLIProxyAPI/v7/internal/config" cliproxyauth "github.com/router-for-me/CLIProxyAPI/v7/sdk/cliproxy/auth" cliproxyexecutor "github.com/router-for-me/CLIProxyAPI/v7/sdk/cliproxy/executor" sdktranslator "github.com/router-for-me/CLIProxyAPI/v7/sdk/translator" "github.com/tidwall/gjson")
func TestNewKimiExecutorInitializesDelegatedClaudeConfig(t *testing.T) { cfg := &config.Config{SDKConfig: config.SDKConfig{RequestLog: true}} executor := NewKimiExecutor(cfg)
if executor.cfg != cfg { t.Fatal("Kimi executor config was not initialized") } if executor.ClaudeExecutor.cfg != cfg { t.Fatal("delegated Claude executor config was not initialized") }}
func TestKimiExecutorRequestToFormatMatchesWireProtocol(t *testing.T) { type requestToFormatReporter interface { RequestToFormat(cliproxyexecutor.Request, cliproxyexecutor.Options) sdktranslator.Format }
executor := NewKimiExecutor(&config.Config{}) reporter, ok := any(executor).(requestToFormatReporter) if !ok { t.Fatal("Kimi executor does not report its upstream request format") }
tests := []struct { name string stream bool source sdktranslator.Format want sdktranslator.Format }{ {name: "Claude non-streaming", source: sdktranslator.FormatClaude, want: sdktranslator.FormatClaude}, {name: "Claude streaming", stream: true, source: sdktranslator.FormatClaude, want: sdktranslator.FormatClaude}, {name: "OpenAI non-streaming", source: sdktranslator.FormatOpenAI, want: sdktranslator.FormatOpenAI}, {name: "OpenAI streaming", stream: true, source: sdktranslator.FormatOpenAI, want: sdktranslator.FormatOpenAI}, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { got := reporter.RequestToFormat(cliproxyexecutor.Request{}, cliproxyexecutor.Options{ SourceFormat: tt.source, Stream: tt.stream, }) if got != tt.want { t.Fatalf("RequestToFormat() = %q, want %q", got, tt.want) } }) }}
func TestKimiUsesNativeMessages(t *testing.T) { tests := []struct { name string format sdktranslator.Format payload string want bool }{ {name: "Claude requests use native messages", format: sdktranslator.FormatClaude, payload: `{"tools":[{"type":"web_search"}]}`, want: true}, {name: "Responses requests with regular tools use native messages", format: sdktranslator.FormatOpenAIResponse, payload: `{"tools":[{"type":"function","name":"exec_command"}]}`, want: true}, {name: "Responses requests with web search use chat completions", format: sdktranslator.FormatOpenAIResponse, payload: `{"tools":[{"type":"web_search"}]}`, want: false}, {name: "Chat completions requests use chat completions", format: sdktranslator.FormatOpenAI, payload: `{"tools":[{"type":"function","name":"exec_command"}]}`, want: false}, }
for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { if got := kimiUsesNativeMessages(tt.format, []byte(tt.payload)); got != tt.want { t.Fatalf("kimiUsesNativeMessages() = %t, want %t", got, tt.want) } }) }}
func TestKimiExecutorClaudeRequestPreservesInternalModelSemantics(t *testing.T) { var upstreamBody []byte ctx := context.WithValue(context.Background(), "cliproxy.roundtripper", kimiRoundTripperFunc(func(req *http.Request) (*http.Response, error) { var errRead error upstreamBody, errRead = io.ReadAll(req.Body) if errRead != nil { return nil, errRead } return &http.Response{ StatusCode: http.StatusOK, Header: http.Header{"Content-Type": []string{"application/json"}}, Body: io.NopCloser(strings.NewReader( `{"id":"msg_test","type":"message","role":"assistant","model":"k2.5","content":[{"type":"text","text":"hello"}],"stop_reason":"end_turn","usage":{"input_tokens":1,"output_tokens":1}}`, )), }, nil }))
executor := NewKimiExecutor(&config.Config{}) auth := &cliproxyauth.Auth{ Attributes: map[string]string{}, Metadata: map[string]any{"access_token": "test-token"}, } const model = "kimi-k2.5(max)" payload := []byte(`{"model":"kimi-k2.5(max)","max_tokens":32,"messages":[{"role":"user","content":"hello"}]}`) response, err := executor.Execute(ctx, auth, cliproxyexecutor.Request{ Model: model, Payload: payload, }, cliproxyexecutor.Options{ SourceFormat: sdktranslator.FormatClaude, OriginalRequest: payload, }) if err != nil { t.Fatalf("Execute() error = %v", err) } if got := gjson.GetBytes(upstreamBody, "model").String(); got != "k2.5" { t.Fatalf("upstream model = %q, want k2.5", got) } if got := gjson.GetBytes(upstreamBody, "output_config.effort").String(); got != "high" { t.Fatalf("upstream output_config.effort = %q, want high", got) } if got := gjson.GetBytes(response.Payload, "model").String(); got != model { t.Fatalf("response model = %q, want %q", got, model) }}
func TestKimiExecutorPreservesAssistantContentAndToolCallsFromResponsesHistory(t *testing.T) { var upstreamBody []byte ctx := context.WithValue(context.Background(), "cliproxy.roundtripper", kimiRoundTripperFunc(func(req *http.Request) (*http.Response, error) { var errRead error upstreamBody, errRead = io.ReadAll(req.Body) if errRead != nil { return nil, errRead } return &http.Response{ StatusCode: http.StatusOK, Header: http.Header{"Content-Type": []string{"text/event-stream"}}, Body: io.NopCloser(strings.NewReader( "event: message_start\n" + `data: {"type":"message_start","message":{"id":"msg_test","type":"message","role":"assistant","model":"k3","content":[],"stop_reason":null,"usage":{"input_tokens":1,"output_tokens":0}}}` + "\n\n" + "event: message_delta\n" + `data: {"type":"message_delta","delta":{"stop_reason":"end_turn","stop_sequence":null},"usage":{"output_tokens":1}}` + "\n\n" + "event: message_stop\n" + `data: {"type":"message_stop"}` + "\n\n", )), }, nil }))
executor := NewKimiExecutor(&config.Config{}) auth := &cliproxyauth.Auth{ Attributes: map[string]string{}, Metadata: map[string]any{"access_token": "test-token"}, } payload := []byte(`{ "model":"kimi-k3", "input":[ {"type":"reasoning","id":"rs_1","summary":[{"type":"summary_text","text":"inspect the next step"}]}, {"type":"message","role":"assistant","content":[{"type":"output_text","text":"Step 3 completed; continue to step 4."}]}, {"type":"function_call","call_id":"call_4","name":"exec_command","arguments":"{\"cmd\":\"pwd\"}"}, {"type":"function_call_output","call_id":"call_4","output":"ok"} ] }`)
_, err := executor.Execute(ctx, auth, cliproxyexecutor.Request{ Model: "kimi-k3", Payload: payload, }, cliproxyexecutor.Options{ SourceFormat: sdktranslator.FormatOpenAIResponse, OriginalRequest: payload, }) if err != nil { t.Fatalf("Execute() error = %v", err) }
messages := gjson.GetBytes(upstreamBody, "messages").Array() if got := len(messages); got != 2 { t.Fatalf("upstream messages count = %d, want 2; body=%s", got, upstreamBody) } assistant := messages[0] if got := assistant.Get("content.0.text").String(); got != "Step 3 completed; continue to step 4." { t.Fatalf("assistant content = %q, want preserved text; body=%s", got, upstreamBody) } if got := assistant.Get("content.1.type").String(); got != "tool_use" { t.Fatalf("assistant tool content type = %q, want tool_use; body=%s", got, upstreamBody) } if got := assistant.Get("content.1.id").String(); got != "call_4" { t.Fatalf("assistant tool call ID = %q, want call_4; body=%s", got, upstreamBody) } if got := messages[1].Get(`content.#(tool_use_id=="call_4").tool_use_id`).String(); got != "call_4" { t.Fatalf("tool output call ID = %q, want call_4; body=%s", got, upstreamBody) }}
func TestKimiExecutorCountTokensUsesCanonicalUpstreamModel(t *testing.T) { var upstreamRequest *http.Request var upstreamBody []byte ctx := context.WithValue(context.Background(), "cliproxy.roundtripper", kimiRoundTripperFunc(func(req *http.Request) (*http.Response, error) { upstreamRequest = req.Clone(req.Context()) var errRead error upstreamBody, errRead = io.ReadAll(req.Body) if errRead != nil { return nil, errRead } return &http.Response{ StatusCode: http.StatusOK, Header: http.Header{"Content-Type": []string{"application/json"}}, Body: io.NopCloser(strings.NewReader(`{"input_tokens":42}`)), }, nil }))
executor := NewKimiExecutor(&config.Config{}) auth := &cliproxyauth.Auth{ Attributes: map[string]string{}, Metadata: map[string]any{"access_token": "test-token"}, } payload := []byte(`{"model":"kimi-k3[1m](high)","messages":[{"role":"user","content":"hello"}]}`) _, err := executor.CountTokens(ctx, auth, cliproxyexecutor.Request{ Model: "kimi-k3[1m](high)", Payload: payload, }, cliproxyexecutor.Options{SourceFormat: sdktranslator.FormatClaude}) if err != nil { t.Fatalf("CountTokens() error = %v", err) } if upstreamRequest == nil { t.Fatal("upstream request was not captured") } if got := upstreamRequest.URL.String(); got != "https://api.kimi.com/coding/v1/messages/count_tokens?beta=true" { t.Fatalf("upstream URL = %q, want Kimi count tokens endpoint", got) } if got := gjson.GetBytes(upstreamBody, "model").String(); got != "k3" { t.Fatalf("upstream model = %q, want k3", got) }}
func TestKimiExecutorCountTokensInvalidGzipErrorBodyReturnsDecodeMessage(t *testing.T) { ctx := context.WithValue(context.Background(), "cliproxy.roundtripper", kimiRoundTripperFunc(func(req *http.Request) (*http.Response, error) { return &http.Response{ StatusCode: http.StatusBadRequest, Header: http.Header{"Content-Encoding": []string{"gzip"}}, Body: io.NopCloser(strings.NewReader("not-a-valid-gzip-stream")), }, nil }))
executor := NewKimiExecutor(&config.Config{}) auth := &cliproxyauth.Auth{ Attributes: map[string]string{}, Metadata: map[string]any{"access_token": "test-token"}, } payload := []byte(`{"model":"kimi-k3","messages":[{"role":"user","content":"hello"}]}`) _, err := executor.CountTokens(ctx, auth, cliproxyexecutor.Request{ Model: "kimi-k3", Payload: payload, }, cliproxyexecutor.Options{SourceFormat: sdktranslator.FormatClaude}) assertStatusErr(t, err, http.StatusBadRequest) if !strings.Contains(err.Error(), "failed to decode error response body") { t.Fatalf("CountTokens() error = %q, want decode failure", err) }}
func TestKimiExecutorClaudeStreamForwardsAnthropicBetaAndLogsUpstream(t *testing.T) { gin.SetMode(gin.TestMode) recorder := httptest.NewRecorder() ginCtx, _ := gin.CreateTestContext(recorder) ginCtx.Request = httptest.NewRequest(http.MethodPost, "/v1/messages?beta=true", nil)
var upstreamRequest *http.Request ctx := context.WithValue(context.Background(), "gin", ginCtx) ctx = context.WithValue(ctx, "cliproxy.roundtripper", kimiRoundTripperFunc(func(req *http.Request) (*http.Response, error) { upstreamRequest = req.Clone(req.Context()) upstreamRequest.Header = req.Header.Clone() return &http.Response{ StatusCode: http.StatusOK, Header: http.Header{"Content-Type": []string{"text/event-stream"}}, Body: io.NopCloser(strings.NewReader( "event: message_start\n" + `data: {"type":"message_start","message":{"id":"msg_test","type":"message","role":"assistant","model":"k3","content":[],"stop_reason":null,"stop_sequence":null,"usage":{"input_tokens":1,"output_tokens":0}}}` + "\n\n" + "event: message_stop\n" + `data: {"type":"message_stop"}` + "\n\n", )), }, nil }))
cfg := &config.Config{SDKConfig: config.SDKConfig{RequestLog: true}} executor := NewKimiExecutor(cfg) auth := &cliproxyauth.Auth{ ID: "kimi-test-auth", Attributes: map[string]string{}, Metadata: map[string]any{"access_token": "test-token"}, } payload := []byte(`{"model":"kimi-k3","max_tokens":32,"messages":[{"role":"user","content":"hello"}]}`) result, err := executor.ExecuteStream(ctx, auth, cliproxyexecutor.Request{ Model: "kimi-k3", Payload: payload, }, cliproxyexecutor.Options{ Stream: true, SourceFormat: sdktranslator.FormatClaude, OriginalRequest: payload, Headers: http.Header{ "Anthropic-Beta": []string{"client-beta-one", "client-beta-two"}, }, }) if err != nil { t.Fatalf("ExecuteStream() error = %v", err) } var output strings.Builder for chunk := range result.Chunks { if chunk.Err != nil { t.Fatalf("stream chunk error = %v", chunk.Err) } output.Write(chunk.Payload) } if !strings.Contains(output.String(), `"model":"kimi-k3"`) { t.Fatalf("stream output = %q, want requested model kimi-k3", output.String()) } if upstreamRequest == nil { t.Fatal("upstream request was not captured") } if got := upstreamRequest.URL.String(); got != "https://api.kimi.com/coding/v1/messages?beta=true" { t.Fatalf("upstream URL = %q, want Kimi messages endpoint", got) } upstreamBetas := upstreamRequest.Header.Get("Anthropic-Beta") if upstreamBetas != "client-beta-one,client-beta-two" { t.Fatalf("Anthropic-Beta = %q, want caller beta values only", upstreamBetas) }
rawAPIRequest, existsRequest := ginCtx.Get("API_REQUEST") apiRequest, okRequest := rawAPIRequest.([]byte) if !existsRequest || !okRequest { t.Fatalf("API_REQUEST = %#v, want captured bytes", rawAPIRequest) } apiRequestText := string(apiRequest) for _, want := range []string{ "=== API REQUEST 1 ===", "Upstream URL: https://api.kimi.com/coding/v1/messages?beta=true", "Auth: provider=kimi", "Anthropic-Beta: " + upstreamBetas, `"model":"k3"`, } { if !strings.Contains(apiRequestText, want) { t.Fatalf("API_REQUEST = %q, want %q", apiRequestText, want) } } if strings.Contains(apiRequestText, "<missing>") { t.Fatalf("API_REQUEST = %q, want captured upstream request", apiRequestText) }
rawAPIResponse, existsResponse := ginCtx.Get("API_RESPONSE") apiResponse, okResponse := rawAPIResponse.([]byte) if !existsResponse || !okResponse { t.Fatalf("API_RESPONSE = %#v, want captured bytes", rawAPIResponse) } apiResponseText := string(apiResponse) for _, want := range []string{"=== API RESPONSE 1 ===", "Status: 200", `data: {"type":"message_stop"}`} { if !strings.Contains(apiResponseText, want) { t.Fatalf("API_RESPONSE = %q, want %q", apiResponseText, want) } }}
type kimiRoundTripperFunc func(*http.Request) (*http.Response, error)
func (f kimiRoundTripperFunc) RoundTrip(req *http.Request) (*http.Response, error) { return f(req)}
func TestNormalizeKimiToolMessageLinks_UsesCallIDFallback(t *testing.T) { body := []byte(`{ "messages":[ {"role":"assistant","tool_calls":[{"id":"list_directory:1","type":"function","function":{"name":"list_directory","arguments":"{}"}}]}, {"role":"tool","call_id":"list_directory:1","content":"[]"} ] }`)
out, err := normalizeKimiToolMessageLinks(body) if err != nil { t.Fatalf("normalizeKimiToolMessageLinks() error = %v", err) }
got := gjson.GetBytes(out, "messages.1.tool_call_id").String() if got != "list_directory:1" { t.Fatalf("messages.1.tool_call_id = %q, want %q", got, "list_directory:1") }}
func TestNormalizeKimiToolMessageLinks_InferSinglePendingID(t *testing.T) { body := []byte(`{ "messages":[ {"role":"assistant","tool_calls":[{"id":"call_123","type":"function","function":{"name":"read_file","arguments":"{}"}}]}, {"role":"tool","content":"file-content"} ] }`)
out, err := normalizeKimiToolMessageLinks(body) if err != nil { t.Fatalf("normalizeKimiToolMessageLinks() error = %v", err) }
got := gjson.GetBytes(out, "messages.1.tool_call_id").String() if got != "call_123" { t.Fatalf("messages.1.tool_call_id = %q, want %q", got, "call_123") }}
func TestNormalizeKimiToolMessageLinks_AmbiguousMissingIDIsNotInferred(t *testing.T) { body := []byte(`{ "messages":[ {"role":"assistant","tool_calls":[ {"id":"call_1","type":"function","function":{"name":"list_directory","arguments":"{}"}}, {"id":"call_2","type":"function","function":{"name":"read_file","arguments":"{}"}} ]}, {"role":"tool","content":"result-without-id"} ] }`)
out, err := normalizeKimiToolMessageLinks(body) if err != nil { t.Fatalf("normalizeKimiToolMessageLinks() error = %v", err) }
if gjson.GetBytes(out, "messages.1.tool_call_id").Exists() { t.Fatalf("messages.1.tool_call_id should be absent for ambiguous case, got %q", gjson.GetBytes(out, "messages.1.tool_call_id").String()) }}
func TestNormalizeKimiToolMessageLinks_PreservesExistingToolCallID(t *testing.T) { body := []byte(`{ "messages":[ {"role":"assistant","tool_calls":[{"id":"call_1","type":"function","function":{"name":"list_directory","arguments":"{}"}}]}, {"role":"tool","tool_call_id":"call_1","call_id":"different-id","content":"result"} ] }`)
out, err := normalizeKimiToolMessageLinks(body) if err != nil { t.Fatalf("normalizeKimiToolMessageLinks() error = %v", err) }
got := gjson.GetBytes(out, "messages.1.tool_call_id").String() if got != "call_1" { t.Fatalf("messages.1.tool_call_id = %q, want %q", got, "call_1") }}
func TestNormalizeKimiToolMessageLinks_InheritsPreviousReasoningForAssistantToolCalls(t *testing.T) { body := []byte(`{ "messages":[ {"role":"assistant","content":"plan","reasoning_content":"previous reasoning"}, {"role":"assistant","tool_calls":[{"id":"call_1","type":"function","function":{"name":"list_directory","arguments":"{}"}}]} ] }`)
out, err := normalizeKimiToolMessageLinks(body) if err != nil { t.Fatalf("normalizeKimiToolMessageLinks() error = %v", err) }
got := gjson.GetBytes(out, "messages.1.reasoning_content").String() if got != "previous reasoning" { t.Fatalf("messages.1.reasoning_content = %q, want %q", got, "previous reasoning") }}
func TestNormalizeKimiToolMessageLinks_InsertsFallbackReasoningWhenMissing(t *testing.T) { body := []byte(`{ "messages":[ {"role":"assistant","tool_calls":[{"id":"call_1","type":"function","function":{"name":"list_directory","arguments":"{}"}}]} ] }`)
out, err := normalizeKimiToolMessageLinks(body) if err != nil { t.Fatalf("normalizeKimiToolMessageLinks() error = %v", err) }
reasoning := gjson.GetBytes(out, "messages.0.reasoning_content") if !reasoning.Exists() { t.Fatalf("messages.0.reasoning_content should exist") } if reasoning.String() != "[reasoning unavailable]" { t.Fatalf("messages.0.reasoning_content = %q, want %q", reasoning.String(), "[reasoning unavailable]") }}
func TestNormalizeKimiToolMessageLinks_DoesNotReuseUnavailableReasoning(t *testing.T) { body := []byte(`{ "messages":[ {"role":"assistant","reasoning_content":"[reasoning unavailable]"}, {"role":"assistant","content":"current summary","tool_calls":[{"id":"call_1","type":"function","function":{"name":"list_directory","arguments":"{}"}}]} ] }`)
out, err := normalizeKimiToolMessageLinks(body) if err != nil { t.Fatalf("normalizeKimiToolMessageLinks() error = %v", err) }
got := gjson.GetBytes(out, "messages.1.reasoning_content").String() if got != "current summary" { t.Fatalf("messages.1.reasoning_content = %q, want %q", got, "current summary") }}
func TestNormalizeKimiToolMessageLinks_UnavailableReasoningDoesNotOverridePreviousReasoning(t *testing.T) { body := []byte(`{ "messages":[ {"role":"assistant","reasoning_content":"real reasoning"}, {"role":"assistant","reasoning_content":"[reasoning unavailable]"}, {"role":"assistant","tool_calls":[{"id":"call_1","type":"function","function":{"name":"list_directory","arguments":"{}"}}]} ] }`)
out, err := normalizeKimiToolMessageLinks(body) if err != nil { t.Fatalf("normalizeKimiToolMessageLinks() error = %v", err) }
got := gjson.GetBytes(out, "messages.2.reasoning_content").String() if got != "real reasoning" { t.Fatalf("messages.2.reasoning_content = %q, want %q", got, "real reasoning") }}
func TestNormalizeKimiToolMessageLinks_ReplacesUnavailableReasoningContent(t *testing.T) { body := []byte(`{ "messages":[ {"role":"assistant","content":"assistant summary","tool_calls":[{"id":"call_1","type":"function","function":{"name":"list_directory","arguments":"{}"}}],"reasoning_content":"[reasoning unavailable]"} ] }`)
out, err := normalizeKimiToolMessageLinks(body) if err != nil { t.Fatalf("normalizeKimiToolMessageLinks() error = %v", err) }
got := gjson.GetBytes(out, "messages.0.reasoning_content").String() if got != "assistant summary" { t.Fatalf("messages.0.reasoning_content = %q, want %q", got, "assistant summary") }}
func TestNormalizeKimiToolMessageLinks_UsesContentAsReasoningFallback(t *testing.T) { body := []byte(`{ "messages":[ {"role":"assistant","content":[{"type":"text","text":"first line"},{"type":"text","text":"second line"}],"tool_calls":[{"id":"call_1","type":"function","function":{"name":"list_directory","arguments":"{}"}}]} ] }`)
out, err := normalizeKimiToolMessageLinks(body) if err != nil { t.Fatalf("normalizeKimiToolMessageLinks() error = %v", err) }
got := gjson.GetBytes(out, "messages.0.reasoning_content").String() if got != "first line\nsecond line" { t.Fatalf("messages.0.reasoning_content = %q, want %q", got, "first line\nsecond line") }}
func TestNormalizeKimiToolMessageLinks_ReplacesEmptyReasoningContent(t *testing.T) { body := []byte(`{ "messages":[ {"role":"assistant","content":"assistant summary","tool_calls":[{"id":"call_1","type":"function","function":{"name":"list_directory","arguments":"{}"}}],"reasoning_content":""} ] }`)
out, err := normalizeKimiToolMessageLinks(body) if err != nil { t.Fatalf("normalizeKimiToolMessageLinks() error = %v", err) }
got := gjson.GetBytes(out, "messages.0.reasoning_content").String() if got != "assistant summary" { t.Fatalf("messages.0.reasoning_content = %q, want %q", got, "assistant summary") }}
func TestNormalizeKimiToolMessageLinks_PreservesExistingAssistantReasoning(t *testing.T) { body := []byte(`{ "messages":[ {"role":"assistant","tool_calls":[{"id":"call_1","type":"function","function":{"name":"list_directory","arguments":"{}"}}],"reasoning_content":"keep me"} ] }`)
out, err := normalizeKimiToolMessageLinks(body) if err != nil { t.Fatalf("normalizeKimiToolMessageLinks() error = %v", err) }
got := gjson.GetBytes(out, "messages.0.reasoning_content").String() if got != "keep me" { t.Fatalf("messages.0.reasoning_content = %q, want %q", got, "keep me") }}
func TestNormalizeKimiToolMessageLinks_RepairsIDsAndReasoningTogether(t *testing.T) { body := []byte(`{ "messages":[ {"role":"assistant","tool_calls":[{"id":"call_1","type":"function","function":{"name":"list_directory","arguments":"{}"}}],"reasoning_content":"r1"}, {"role":"tool","call_id":"call_1","content":"[]"}, {"role":"assistant","tool_calls":[{"id":"call_2","type":"function","function":{"name":"read_file","arguments":"{}"}}]}, {"role":"tool","call_id":"call_2","content":"file"} ] }`)
out, err := normalizeKimiToolMessageLinks(body) if err != nil { t.Fatalf("normalizeKimiToolMessageLinks() error = %v", err) }
if got := gjson.GetBytes(out, "messages.1.tool_call_id").String(); got != "call_1" { t.Fatalf("messages.1.tool_call_id = %q, want %q", got, "call_1") } if got := gjson.GetBytes(out, "messages.3.tool_call_id").String(); got != "call_2" { t.Fatalf("messages.3.tool_call_id = %q, want %q", got, "call_2") } if got := gjson.GetBytes(out, "messages.2.reasoning_content").String(); got != "r1" { t.Fatalf("messages.2.reasoning_content = %q, want %q", got, "r1") }}
func TestNormalizeKimiToolMessageLinks_DropsEmptyAssistantWithoutToolLink(t *testing.T) { body := []byte(`{ "messages":[ {"role":"user","content":"start"}, {"role":"assistant","content":""}, {"role":"assistant","content":" "}, {"role":"assistant","content":"","tool_calls":null}, {"role":"assistant","content":[{"type":"text","text":" "}]}, {"role":"assistant"}, {"role":"assistant","content":"keep"}, {"role":"user","content":"next"} ] }`)
out, err := normalizeKimiToolMessageLinks(body) if err != nil { t.Fatalf("normalizeKimiToolMessageLinks() error = %v", err) }
messages := gjson.GetBytes(out, "messages").Array() if len(messages) != 3 { t.Fatalf("messages length = %d, want 3, raw = %s", len(messages), gjson.GetBytes(out, "messages").Raw) } if got := messages[0].Get("content").String(); got != "start" { t.Fatalf("messages.0.content = %q, want %q", got, "start") } if got := messages[1].Get("content").String(); got != "keep" { t.Fatalf("messages.1.content = %q, want %q", got, "keep") } if got := messages[2].Get("content").String(); got != "next" { t.Fatalf("messages.2.content = %q, want %q", got, "next") }}
func TestNormalizeKimiToolMessageLinks_PreservesAssistantWithToolLinkOrReasoning(t *testing.T) { body := []byte(`{ "messages":[ {"role":"assistant","content":"","tool_calls":[{"id":"call_1","type":"function","function":{"name":"list_directory","arguments":"{}"}}]}, {"role":"assistant","content":"","function_call":{"name":"legacy_call","arguments":"{}"}}, {"role":"assistant","content":"","reasoning_content":"thought"}, {"role":"assistant","content":[{"type":"text","text":" visible "}]} ] }`)
out, err := normalizeKimiToolMessageLinks(body) if err != nil { t.Fatalf("normalizeKimiToolMessageLinks() error = %v", err) }
messages := gjson.GetBytes(out, "messages").Array() if len(messages) != 4 { t.Fatalf("messages length = %d, want 4, raw = %s", len(messages), gjson.GetBytes(out, "messages").Raw) } if !messages[0].Get("tool_calls").Exists() { t.Fatalf("messages.0.tool_calls should exist") } if !messages[1].Get("function_call").Exists() { t.Fatalf("messages.1.function_call should exist") } if got := messages[2].Get("reasoning_content").String(); got != "thought" { t.Fatalf("messages.2.reasoning_content = %q, want %q", got, "thought") } if got := messages[3].Get("content.0.text").String(); got != " visible " { t.Fatalf("messages.3.content.0.text = %q, want %q", got, " visible ") }}
func TestNormalizeKimiUpstreamModel(t *testing.T) { cases := []struct { in string want string }{ {"kimi-k3[1m]", "k3"}, {"kimi-k3", "k3"}, {"Kimi-K3[1M]", "k3"}, {"k3[1m]", "k3"}, {"k3", "k3"}, {"kimi-k2.6", "k2.6"}, {"kimi-k2.6[1m]", "k2.6"}, {"kimi-k3(1024)", "k3(1024)"}, {"kimi-k3[1m](1024)", "k3(1024)"}, {"kimi-k2.6(high)", "k2.6(high)"}, {"kimi-k2.6[1m](high)", "k2.6(high)"}, {"kimi-k2.7-code", "kimi-for-coding"}, {"kimi-k2.7-code-highspeed", "kimi-for-coding-highspeed"}, {"Kimi-K2.7-Code", "kimi-for-coding"}, {"kimi-k2.7-code-highspeed(high)", "kimi-for-coding-highspeed(high)"}, {"kimi-k2.7-code[1m](high)", "kimi-for-coding(high)"}, {"k2.7-code", "kimi-for-coding"}, {"k2.7-code-highspeed", "kimi-for-coding-highspeed"}, {"kimi-for-coding", "kimi-for-coding"}, {"kimi-for-coding-highspeed", "kimi-for-coding-highspeed"}, {"Kimi-For-Coding", "kimi-for-coding"}, {"kimi-for-coding-highspeed(high)", "kimi-for-coding-highspeed(high)"}, {"kimi-for-coding[1m]", "kimi-for-coding"}, {"for-coding", "kimi-for-coding"}, {"for-coding-highspeed", "kimi-for-coding-highspeed"}, }
for _, c := range cases { got := normalizeKimiUpstreamModel(c.in) if got != c.want { t.Errorf("normalizeKimiUpstreamModel(%q) = %q, want %q", c.in, got, c.want) } }}
func TestKimiExecutorNormalizesToolSchemasForMoonshot(t *testing.T) { var upstreamBody []byte ctx := context.WithValue(context.Background(), "cliproxy.roundtripper", kimiRoundTripperFunc(func(req *http.Request) (*http.Response, error) { var errRead error upstreamBody, errRead = io.ReadAll(req.Body) if errRead != nil { return nil, errRead } return &http.Response{ StatusCode: http.StatusOK, Header: http.Header{"Content-Type": []string{"application/json"}}, Body: io.NopCloser(strings.NewReader( `{"id":"chatcmpl_test","object":"chat.completion","created":1,"model":"k3","choices":[{"index":0,"message":{"role":"assistant","content":"ok"},"finish_reason":"stop"}],"usage":{"prompt_tokens":1,"completion_tokens":1,"total_tokens":2}}`, )), }, nil }))
executor := NewKimiExecutor(&config.Config{}) auth := &cliproxyauth.Auth{ Attributes: map[string]string{}, Metadata: map[string]any{"access_token": "test-token"}, }
// Tool with $defs and $ref sibling type, matching the shape used by Codex Desktop app tools payload := []byte(`{ "model":"kimi-k3", "messages":[{"role":"user","content":"hello"}], "tools":[ { "type":"function", "function":{ "name":"codex_app__automation_update", "description":"Update automation", "parameters":{ "$defs":{ "value":{ "type":"string" } }, "type":"object", "properties":{ "value":{ "$ref":"#/$defs/value", "type":"string", "description":"A value" } } } } } ] }`)
_, err := executor.Execute(ctx, auth, cliproxyexecutor.Request{ Model: "kimi-k3", Payload: payload, }, cliproxyexecutor.Options{ SourceFormat: sdktranslator.FormatOpenAI, OriginalRequest: payload, }) if err != nil { t.Fatalf("Execute() error = %v", err) }
tool := gjson.GetBytes(upstreamBody, "tools.0.function") if !tool.Exists() { t.Fatalf("upstream tool function not found: %s", upstreamBody) }
// Moonshot rejects $ref with sibling type; verify $ref is inlined and removed if ref := tool.Get("parameters.properties.value.$ref"); ref.Exists() { t.Fatalf("upstream tool parameter still contains $ref: %s", tool.Get("parameters").Raw) } if got := tool.Get("parameters.properties.value.type").String(); got != "string" { t.Fatalf("upstream tool parameter value.type = %q, want %q", got, "string") } if got := tool.Get("parameters.properties.value.description").String(); got != "A value" { t.Fatalf("upstream tool parameter value.description = %q, want %q", got, "A value") } // Verify $defs container was pruned if defs := tool.Get("parameters.$defs"); defs.Exists() { t.Fatalf("upstream tool parameter still contains $defs: %s", tool.Get("parameters").Raw) } // Verify explicit object type if got := tool.Get("parameters.type").String(); got != "object" { t.Fatalf("upstream tool parameters.type = %q, want %q", got, "object") }}
func TestKimiExecutorStreamNormalizesToolSchemasFromResponses(t *testing.T) { var upstreamBody []byte ctx := context.WithValue(context.Background(), "cliproxy.roundtripper", kimiRoundTripperFunc(func(req *http.Request) (*http.Response, error) { var errRead error upstreamBody, errRead = io.ReadAll(req.Body) if errRead != nil { return nil, errRead } return &http.Response{ StatusCode: http.StatusOK, Header: http.Header{"Content-Type": []string{"text/event-stream"}}, Body: io.NopCloser(strings.NewReader( "data: {\"id\":\"chatcmpl_1\",\"object\":\"chat.completion.chunk\",\"created\":1,\"model\":\"k3\",\"choices\":[{\"index\":0,\"delta\":{\"content\":\"hello\"},\"finish_reason\":null}]}\n\n" + "data: [DONE]\n\n", )), }, nil }))
executor := NewKimiExecutor(&config.Config{}) auth := &cliproxyauth.Auth{ Attributes: map[string]string{}, Metadata: map[string]any{"access_token": "test-token"}, }
// Codex Responses format payload with tools containing $defs and $ref payload := []byte(`{ "model":"kimi-k3", "input":[{"type":"message","role":"user","content":"hello"}], "tools":[ { "type":"function", "name":"codex_app__automation_update", "description":"Update automation", "parameters":{ "$defs":{ "sub":{ "type":"string" } }, "properties":{ "field":{ "$ref":"#/$defs/sub", "type":"string" } } } } ] }`)
streamResult, err := executor.ExecuteStream(ctx, auth, cliproxyexecutor.Request{ Model: "kimi-k3", Payload: payload, }, cliproxyexecutor.Options{ SourceFormat: sdktranslator.FormatOpenAIResponse, OriginalRequest: payload, Stream: true, }) if err != nil { t.Fatalf("ExecuteStream() error = %v", err) } if streamResult != nil && streamResult.Chunks != nil { for range streamResult.Chunks { } }
tool := gjson.GetBytes(upstreamBody, "tools.0.function") if !tool.Exists() { t.Fatalf("upstream tool function not found in stream body: %s", upstreamBody) } if ref := tool.Get("parameters.properties.field.$ref"); ref.Exists() { t.Fatalf("upstream stream tool parameter still contains $ref: %s", tool.Get("parameters").Raw) } if got := tool.Get("parameters.properties.field.type").String(); got != "string" { t.Fatalf("upstream stream tool field.type = %q, want %q", got, "string") } if defs := tool.Get("parameters.$defs"); defs.Exists() { t.Fatalf("upstream stream tool parameter still contains $defs: %s", tool.Get("parameters").Raw) } if got := tool.Get("parameters.type").String(); got != "object" { t.Fatalf("upstream stream tool parameters.type = %q, want %q", got, "object") }}
func TestNormalizeKimiToolsDirect(t *testing.T) { input := []byte(`{ "tools":[ { "type":"function", "function":{ "name":"test_fn", "parameters":{ "definitions":{ "prop":{"type":"number"} }, "properties":{ "count":{"$ref":"#/definitions/prop","description":"item count"} } } } } ], "functions":[ { "name":"legacy_fn", "parameters":{ "properties":{"name":{"type":"string"}} } } ] }`)
normalized := normalizeKimiTools(input)
toolParams := gjson.GetBytes(normalized, "tools.0.function.parameters") if toolParams.Get("definitions").Exists() { t.Errorf("definitions was not stripped: %s", toolParams.Raw) } if toolParams.Get("properties.count.$ref").Exists() { t.Errorf("$ref was not inlined: %s", toolParams.Raw) } if got := toolParams.Get("properties.count.type").String(); got != "number" { t.Errorf("properties.count.type = %q, want number", got) } if got := toolParams.Get("properties.count.description").String(); got != "item count" { t.Errorf("properties.count.description = %q, want 'item count'", got) } if got := toolParams.Get("type").String(); got != "object" { t.Errorf("tools.0.function.parameters.type = %q, want object", got) }
fnParams := gjson.GetBytes(normalized, "functions.0.parameters") if got := fnParams.Get("type").String(); got != "object" { t.Errorf("functions.0.parameters.type = %q, want object", got) }}