wehub-resource-sync
120 lines
4.3 KiB
Go
120 lines
4.3 KiB
Go
package main
|
|
|
|
import (
|
|
"encoding/json"
|
|
"strings"
|
|
"testing"
|
|
|
|
pb "github.com/mudler/LocalAI/pkg/grpc/proto"
|
|
. "github.com/onsi/gomega"
|
|
)
|
|
|
|
// Verify buildOpenAIRequest preserves caller-supplied tools and
|
|
// tool_choice as opaque JSON. PredictOptions carries them as strings;
|
|
// they must land in the outbound request body unchanged so the
|
|
// upstream sees the caller's intent verbatim. A regression here would
|
|
// silently disable function calling for translate-mode clients.
|
|
func TestBuildOpenAIRequest_ToolsAndToolChoicePassthrough(t *testing.T) {
|
|
g := NewWithT(t)
|
|
cfg := &proxyConfig{upstreamModel: "gpt-4o"}
|
|
toolsJSON := `[{"type":"function","function":{"name":"search","parameters":{"type":"object"}}}]`
|
|
choiceJSON := `{"type":"function","function":{"name":"search"}}`
|
|
|
|
body, err := buildOpenAIRequest(&pb.PredictOptions{
|
|
Messages: []*pb.Message{{Role: "user", Content: "find x"}},
|
|
Tools: toolsJSON,
|
|
ToolChoice: choiceJSON,
|
|
}, cfg, false)
|
|
g.Expect(err).NotTo(HaveOccurred())
|
|
|
|
var decoded openAIRequest
|
|
err = json.Unmarshal(body, &decoded)
|
|
g.Expect(err).NotTo(HaveOccurred())
|
|
// Compare the JSON-canonical form so whitespace differences are ignored.
|
|
gotTools, _ := json.Marshal(json.RawMessage(decoded.Tools))
|
|
wantTools, _ := json.Marshal(json.RawMessage(toolsJSON))
|
|
g.Expect(string(gotTools)).To(Equal(string(wantTools)))
|
|
gotChoice, _ := json.Marshal(json.RawMessage(decoded.ToolChoice))
|
|
wantChoice, _ := json.Marshal(json.RawMessage(choiceJSON))
|
|
g.Expect(string(gotChoice)).To(Equal(string(wantChoice)))
|
|
}
|
|
|
|
// Garbage JSON in tools / tool_choice is silently dropped (omitted)
|
|
// rather than blowing up the request. Documents the parseRawJSON
|
|
// behaviour — operators shouldn't see hard failures from an upstream
|
|
// caller's mis-formatted tools field.
|
|
func TestBuildOpenAIRequest_InvalidToolsJSONDropped(t *testing.T) {
|
|
g := NewWithT(t)
|
|
cfg := &proxyConfig{upstreamModel: "gpt-4o"}
|
|
body, err := buildOpenAIRequest(&pb.PredictOptions{
|
|
Messages: []*pb.Message{{Role: "user", Content: "x"}},
|
|
Tools: "this is not json",
|
|
ToolChoice: "{also bad",
|
|
}, cfg, false)
|
|
g.Expect(err).NotTo(HaveOccurred())
|
|
g.Expect(string(body)).NotTo(ContainSubstring("this is not json"))
|
|
g.Expect(string(body)).NotTo(ContainSubstring("{also bad"))
|
|
}
|
|
|
|
// Anthropic empty content array yields an empty Reply (not an error).
|
|
// Mirrors how an upstream tool_use-only response might arrive — the
|
|
// content array can legitimately be empty in some edge cases.
|
|
func TestPredictRich_Anthropic_EmptyContent(t *testing.T) {
|
|
g := NewWithT(t)
|
|
srv, _ := fakeAnthropicUpstream(t, func(_ anthropicRequest) (int, string, string) {
|
|
return 200, `{"id":"m1","type":"message","role":"assistant","content":[],"usage":{"input_tokens":3,"output_tokens":0}}`, "application/json"
|
|
})
|
|
defer srv.Close()
|
|
cp := newAnthropicTranslateCloudProxy(t, srv.URL)
|
|
|
|
reply, err := cp.PredictRich(&pb.PredictOptions{
|
|
Messages: []*pb.Message{{Role: "user", Content: "x"}},
|
|
Tokens: 16,
|
|
})
|
|
g.Expect(err).NotTo(HaveOccurred())
|
|
g.Expect(string(reply.GetMessage())).To(Equal(""))
|
|
g.Expect(reply.GetChatDeltas()).To(HaveLen(0))
|
|
g.Expect(reply.GetPromptTokens()).To(Equal(int32(3)))
|
|
}
|
|
|
|
// A truncated / malformed SSE payload mid-stream should be tolerated:
|
|
// the malformed chunk gets skipped (xlog.Debug logged), valid chunks
|
|
// before AND after it still reach the channel.
|
|
func TestPredictStreamRich_OpenAI_TolerantOfBadChunks(t *testing.T) {
|
|
g := NewWithT(t)
|
|
body := strings.Join([]string{
|
|
`data: {"choices":[{"index":0,"delta":{"content":"hello"}}]}`,
|
|
``,
|
|
`data: this-is-not-json{{`,
|
|
``,
|
|
`data: {"choices":[{"index":0,"delta":{"content":" world"}}]}`,
|
|
``,
|
|
`data: [DONE]`,
|
|
``,
|
|
}, "\n")
|
|
|
|
srv, _ := fakeOpenAIUpstream(t, func(_ openAIRequest) (int, string, string) {
|
|
return 200, body, "text/event-stream"
|
|
})
|
|
defer srv.Close()
|
|
cp := newTranslateCloudProxy(t, srv.URL)
|
|
|
|
results := make(chan *pb.Reply, 8)
|
|
done := make(chan error, 1)
|
|
go func() {
|
|
done <- cp.PredictStreamRich(&pb.PredictOptions{
|
|
Messages: []*pb.Message{{Role: "user", Content: "hi"}},
|
|
}, results)
|
|
close(results)
|
|
}()
|
|
|
|
var assembled strings.Builder
|
|
for reply := range results {
|
|
assembled.Write(reply.GetMessage())
|
|
}
|
|
err := <-done
|
|
g.Expect(err).NotTo(HaveOccurred())
|
|
// The good chunks before and after the malformed one both made it through.
|
|
g.Expect(assembled.String()).To(Equal("hello world"))
|
|
}
|