toki
898da6e3af
- Add openai_compat adapter package - Move 02+01 OpenAI compatible adapter files to archive - Fix adapter factory and test files - Update blackbox tests
330 lines
11 KiB
Go
330 lines
11 KiB
Go
package openai_compat
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"fmt"
|
|
"net/http"
|
|
"net/http/httptest"
|
|
"strings"
|
|
"sync"
|
|
"testing"
|
|
|
|
"go.uber.org/zap"
|
|
|
|
"iop/apps/node/internal/runtime"
|
|
"iop/packages/go/config"
|
|
)
|
|
|
|
type fakeSink struct {
|
|
mu sync.Mutex
|
|
events []runtime.RuntimeEvent
|
|
}
|
|
|
|
func (s *fakeSink) Emit(_ context.Context, event runtime.RuntimeEvent) error {
|
|
s.mu.Lock()
|
|
defer s.mu.Unlock()
|
|
s.events = append(s.events, event)
|
|
return nil
|
|
}
|
|
|
|
func (s *fakeSink) all() []runtime.RuntimeEvent {
|
|
s.mu.Lock()
|
|
defer s.mu.Unlock()
|
|
return append([]runtime.RuntimeEvent(nil), s.events...)
|
|
}
|
|
|
|
func TestOpenAICompatCapabilitiesQueryModels(t *testing.T) {
|
|
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
if r.URL.Path != "/v1/models" {
|
|
t.Fatalf("unexpected path %s", r.URL.Path)
|
|
}
|
|
_, _ = w.Write([]byte(`{"object":"list","data":[{"id":"model-a"},{"id":"model-b"}]}`))
|
|
}))
|
|
defer server.Close()
|
|
|
|
adapter := New(config.OpenAICompatConf{
|
|
Provider: "lemonade",
|
|
Endpoint: server.URL,
|
|
Capacity: 10,
|
|
MaxQueue: 20,
|
|
QueueTimeoutMS: 5000,
|
|
RequestTimeoutMS: 10000,
|
|
}, zap.NewNop())
|
|
caps, err := adapter.Capabilities(context.Background())
|
|
if err != nil {
|
|
t.Fatalf("Capabilities failed: %v", err)
|
|
}
|
|
if caps.AdapterName != Name {
|
|
t.Fatalf("AdapterName: got %q want %q", caps.AdapterName, Name)
|
|
}
|
|
if got := strings.Join(caps.Targets, ","); got != "model-a,model-b" {
|
|
t.Fatalf("targets: got %q", got)
|
|
}
|
|
if caps.MaxConcurrency != 10 {
|
|
t.Fatalf("expected MaxConcurrency 10, got %d", caps.MaxConcurrency)
|
|
}
|
|
if caps.MaxQueue != 20 || caps.QueueTimeoutMS != 5000 || caps.RequestTimeoutMS != 10000 {
|
|
t.Fatalf("queue config: got %+v", caps)
|
|
}
|
|
if caps.ProviderStatus != runtime.ProviderStatusAvailable {
|
|
t.Fatalf("expected available, got %s", caps.ProviderStatus)
|
|
}
|
|
|
|
adapterDefault := New(config.OpenAICompatConf{Endpoint: server.URL}, zap.NewNop())
|
|
capsDefault, err := adapterDefault.Capabilities(context.Background())
|
|
if err != nil {
|
|
t.Fatalf("Capabilities failed: %v", err)
|
|
}
|
|
if capsDefault.MaxConcurrency != 8 {
|
|
t.Fatalf("expected default MaxConcurrency 8, got %d", capsDefault.MaxConcurrency)
|
|
}
|
|
}
|
|
|
|
func TestOpenAICompatProbeProviderAvailability(t *testing.T) {
|
|
t.Run("200_ok_and_target_hit", func(t *testing.T) {
|
|
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
if r.URL.Path != "/v1/models" {
|
|
t.Fatalf("unexpected path %s", r.URL.Path)
|
|
}
|
|
_, _ = w.Write([]byte(`{"object":"list","data":[{"id":"model-a"},{"id":"model-b"}]}`))
|
|
}))
|
|
defer server.Close()
|
|
|
|
adapter := New(config.OpenAICompatConf{Provider: "lemonade", Endpoint: server.URL}, zap.NewNop())
|
|
res, err := adapter.ProbeProvider(context.Background(), "model-a")
|
|
if err != nil {
|
|
t.Fatalf("ProbeProvider failed: %v", err)
|
|
}
|
|
if res.Status != runtime.ProviderStatusAvailable {
|
|
t.Errorf("expected available, got %s", res.Status)
|
|
}
|
|
if len(res.Targets) != 2 || res.Targets[0] != "model-a" {
|
|
t.Errorf("unexpected Targets: %+v", res.Targets)
|
|
}
|
|
if res.Metadata["provider"] != "lemonade" {
|
|
t.Errorf("expected provider metadata, got %+v", res.Metadata)
|
|
}
|
|
})
|
|
|
|
t.Run("200_ok_and_target_miss", func(t *testing.T) {
|
|
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
_, _ = w.Write([]byte(`{"object":"list","data":[{"id":"model-a"}]}`))
|
|
}))
|
|
defer server.Close()
|
|
|
|
adapter := New(config.OpenAICompatConf{Endpoint: server.URL}, zap.NewNop())
|
|
res, err := adapter.ProbeProvider(context.Background(), "model-b")
|
|
if err != nil {
|
|
t.Fatalf("ProbeProvider failed: %v", err)
|
|
}
|
|
if res.Status != runtime.ProviderStatusUnavailable {
|
|
t.Errorf("expected unavailable, got %s", res.Status)
|
|
}
|
|
if !strings.Contains(res.Detail, "not found") {
|
|
t.Errorf("expected 'not found' in detail, got %s", res.Detail)
|
|
}
|
|
})
|
|
|
|
t.Run("500_internal_error", func(t *testing.T) {
|
|
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
|
|
w.WriteHeader(http.StatusInternalServerError)
|
|
}))
|
|
defer server.Close()
|
|
|
|
adapter := New(config.OpenAICompatConf{Endpoint: server.URL}, zap.NewNop())
|
|
res, err := adapter.ProbeProvider(context.Background(), "model-a")
|
|
if err != nil {
|
|
t.Fatalf("ProbeProvider failed: %v", err)
|
|
}
|
|
if res.Status != runtime.ProviderStatusUnavailable {
|
|
t.Errorf("expected unavailable, got %s", res.Status)
|
|
}
|
|
})
|
|
|
|
t.Run("empty_target", func(t *testing.T) {
|
|
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
|
|
_, _ = w.Write([]byte(`{"object":"list","data":[{"id":"model-a"}]}`))
|
|
}))
|
|
defer server.Close()
|
|
|
|
adapter := New(config.OpenAICompatConf{Endpoint: server.URL}, zap.NewNop())
|
|
res, err := adapter.ProbeProvider(context.Background(), "")
|
|
if err != nil {
|
|
t.Fatalf("ProbeProvider failed: %v", err)
|
|
}
|
|
if res.Status != runtime.ProviderStatusAvailable {
|
|
t.Errorf("expected available, got %s", res.Status)
|
|
}
|
|
})
|
|
}
|
|
|
|
func TestOpenAICompatExecuteStreamsDeltasAndFinishReason(t *testing.T) {
|
|
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
if r.URL.Path != "/v1/chat/completions" {
|
|
t.Fatalf("unexpected path %s", r.URL.Path)
|
|
}
|
|
w.Header().Set("Content-Type", "text/event-stream")
|
|
_, _ = fmt.Fprintf(w, "data: %s\n\n", `{"choices":[{"delta":{"reasoning_content":"think "}}]}`)
|
|
_, _ = fmt.Fprintf(w, "data: %s\n\n", `{"choices":[{"delta":{"content":"hello "}}]}`)
|
|
_, _ = fmt.Fprintf(w, "data: %s\n\n", `{"choices":[{"delta":{"content":"world"},"finish_reason":"stop"}],"usage":{"prompt_tokens":5,"completion_tokens":2}}`)
|
|
_, _ = fmt.Fprintf(w, "data: [DONE]\n\n")
|
|
}))
|
|
defer server.Close()
|
|
|
|
adapter := New(config.OpenAICompatConf{Endpoint: server.URL}, zap.NewNop())
|
|
sink := &fakeSink{}
|
|
err := adapter.Execute(context.Background(), runtime.ExecutionSpec{
|
|
RunID: "run-1",
|
|
Target: "lemonade-model",
|
|
Input: map[string]any{"prompt": "say hello"},
|
|
}, sink)
|
|
if err != nil {
|
|
t.Fatalf("Execute failed: %v", err)
|
|
}
|
|
|
|
events := sink.all()
|
|
// start + reasoning_delta + delta + delta + complete
|
|
if len(events) != 5 {
|
|
t.Fatalf("expected 5 events, got %d: %+v", len(events), events)
|
|
}
|
|
if events[0].Type != runtime.EventTypeStart {
|
|
t.Fatalf("expected start, got %+v", events[0])
|
|
}
|
|
if events[1].Type != runtime.EventTypeReasoningDelta || events[1].Delta != "think " {
|
|
t.Fatalf("expected reasoning delta, got %+v", events[1])
|
|
}
|
|
if events[2].Delta+events[3].Delta != "hello world" {
|
|
t.Fatalf("unexpected deltas: %q + %q", events[2].Delta, events[3].Delta)
|
|
}
|
|
complete := events[4]
|
|
if complete.Type != runtime.EventTypeComplete {
|
|
t.Fatalf("expected complete, got %+v", complete)
|
|
}
|
|
if complete.Metadata["finish_reason"] != "stop" {
|
|
t.Fatalf("expected finish_reason stop, got %+v", complete.Metadata)
|
|
}
|
|
if complete.Usage == nil || complete.Usage.OutputTokens != 2 || complete.Usage.InputTokens != 5 {
|
|
t.Fatalf("expected usage from chunk, got %+v", complete.Usage)
|
|
}
|
|
}
|
|
|
|
func TestOpenAICompatExecuteSendsHeaders(t *testing.T) {
|
|
var gotAuth, gotContentType string
|
|
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
gotAuth = r.Header.Get("Authorization")
|
|
gotContentType = r.Header.Get("Content-Type")
|
|
w.Header().Set("Content-Type", "text/event-stream")
|
|
_, _ = fmt.Fprintf(w, "data: %s\n\n", `{"choices":[{"delta":{"content":"ok"}}]}`)
|
|
_, _ = fmt.Fprintf(w, "data: [DONE]\n\n")
|
|
}))
|
|
defer server.Close()
|
|
|
|
adapter := New(config.OpenAICompatConf{
|
|
Endpoint: server.URL,
|
|
Headers: map[string]string{
|
|
"Authorization": "Bearer secret-token",
|
|
// A user-provided Content-Type must not override the adapter-owned one.
|
|
"Content-Type": "text/plain",
|
|
},
|
|
}, zap.NewNop())
|
|
sink := &fakeSink{}
|
|
if err := adapter.Execute(context.Background(), runtime.ExecutionSpec{
|
|
RunID: "run-h",
|
|
Target: "lemonade-model",
|
|
Input: map[string]any{"prompt": "hi"},
|
|
}, sink); err != nil {
|
|
t.Fatalf("Execute failed: %v", err)
|
|
}
|
|
if gotAuth != "Bearer secret-token" {
|
|
t.Fatalf("expected Authorization header, got %q", gotAuth)
|
|
}
|
|
if gotContentType != "application/json" {
|
|
t.Fatalf("expected adapter-owned content type, got %q", gotContentType)
|
|
}
|
|
}
|
|
|
|
func TestOpenAICompatExecutePassesOptionsAsTopLevelFields(t *testing.T) {
|
|
var body map[string]any
|
|
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
if err := json.NewDecoder(r.Body).Decode(&body); err != nil {
|
|
t.Fatalf("decode: %v", err)
|
|
}
|
|
w.Header().Set("Content-Type", "text/event-stream")
|
|
_, _ = fmt.Fprintf(w, "data: %s\n\n", `{"choices":[{"delta":{"content":"ok"}}]}`)
|
|
_, _ = fmt.Fprintf(w, "data: [DONE]\n\n")
|
|
}))
|
|
defer server.Close()
|
|
|
|
adapter := New(config.OpenAICompatConf{Endpoint: server.URL}, zap.NewNop())
|
|
sink := &fakeSink{}
|
|
if err := adapter.Execute(context.Background(), runtime.ExecutionSpec{
|
|
RunID: "run-o",
|
|
Target: "lemonade-model",
|
|
Input: map[string]any{
|
|
"prompt": "hi",
|
|
"options": map[string]any{
|
|
"temperature": 0.2,
|
|
"max_tokens": float64(8),
|
|
// adapter-owned fields must not be overridden by options
|
|
"model": "evil",
|
|
"stream": false,
|
|
},
|
|
},
|
|
}, sink); err != nil {
|
|
t.Fatalf("Execute failed: %v", err)
|
|
}
|
|
if body["temperature"] != 0.2 {
|
|
t.Fatalf("expected temperature top-level, got %v", body["temperature"])
|
|
}
|
|
if body["max_tokens"] != float64(8) {
|
|
t.Fatalf("expected max_tokens top-level, got %v", body["max_tokens"])
|
|
}
|
|
if body["model"] != "lemonade-model" {
|
|
t.Fatalf("options must not override model, got %v", body["model"])
|
|
}
|
|
if body["stream"] != true {
|
|
t.Fatalf("options must not override stream, got %v", body["stream"])
|
|
}
|
|
}
|
|
|
|
func TestOpenAICompatExecuteRejectsEmptyEndpointOrModel(t *testing.T) {
|
|
t.Run("empty_endpoint", func(t *testing.T) {
|
|
adapter := New(config.OpenAICompatConf{}, zap.NewNop())
|
|
err := adapter.Execute(context.Background(), runtime.ExecutionSpec{
|
|
RunID: "r", Target: "m", Input: map[string]any{"prompt": "hi"},
|
|
}, &fakeSink{})
|
|
if err == nil || !strings.Contains(err.Error(), "endpoint is required") {
|
|
t.Fatalf("expected endpoint error, got %v", err)
|
|
}
|
|
})
|
|
|
|
t.Run("empty_model", func(t *testing.T) {
|
|
adapter := New(config.OpenAICompatConf{Endpoint: "http://localhost:8000"}, zap.NewNop())
|
|
err := adapter.Execute(context.Background(), runtime.ExecutionSpec{
|
|
RunID: "r", Input: map[string]any{"prompt": "hi"},
|
|
}, &fakeSink{})
|
|
if err == nil || !strings.Contains(err.Error(), "target/model is required") {
|
|
t.Fatalf("expected model error, got %v", err)
|
|
}
|
|
})
|
|
}
|
|
|
|
func TestOpenAICompatJoinOpenAIPathNoDuplicateV1(t *testing.T) {
|
|
cases := []struct {
|
|
endpoint string
|
|
path string
|
|
wantTail string
|
|
}{
|
|
{"http://host:8000", "/v1/models", "/v1/models"},
|
|
{"http://host:8000/", "/v1/chat/completions", "/v1/chat/completions"},
|
|
{"http://host:8000/v1", "/v1/models", "/v1/models"},
|
|
{"http://host:8000/v1/", "/v1/chat/completions", "/v1/chat/completions"},
|
|
}
|
|
for _, c := range cases {
|
|
got := joinOpenAIPath(strings.TrimRight(c.endpoint, "/"), c.path)
|
|
if !strings.HasSuffix(got, c.wantTail) || strings.Contains(got, "/v1/v1") {
|
|
t.Errorf("joinOpenAIPath(%q,%q)=%q want suffix %q without /v1/v1", c.endpoint, c.path, got, c.wantTail)
|
|
}
|
|
}
|
|
}
|