Skip to content

RAGFlow is an agent-native database: a Retrieval-Augmented Generation (RAG) engine that grew into context infrastructure.

29.9 KB
Raw Blame
package models

import (
	"encoding/json"
	"io"
	"net/http"
	"net/http/httptest"
	"ragflow/internal/common"
	"reflect"
	"slices"
	"sort"
	"strings"
	"testing"
)

func newGPUStackServer(t *testing.T, expectedPath string, handler func(t *testing.T, body map[string]interface{}, w http.ResponseWriter)) *httptest.Server {
	t.Helper()
	return httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		if r.URL.Path != expectedPath {
			t.Errorf("expected path=%s, got %s", expectedPath, r.URL.Path)
			return
		}
		if got := r.Header.Get("Authorization"); got != "Bearer test-key" {
			t.Errorf("expected Authorization=Bearer test-key, got %q", got)
			return
		}
		if r.Method == http.MethodPost {
			if got := r.Header.Get("Content-Type"); !strings.HasPrefix(got, "application/json") {
				t.Errorf("expected Content-Type to start with application/json, got %q", got)
				return
			}
			raw, err := io.ReadAll(r.Body)
			if err != nil {
				t.Errorf("read body: %v", err)
				return
			}
			var body map[string]interface{}
			if err := json.Unmarshal(raw, &body); err != nil {
				t.Errorf("unmarshal: %v\nraw=%s", err, string(raw))
				return
			}
			handler(t, body, w)
			return
		}
		handler(t, nil, w)
	}))
}

func newGPUStackSSEServer(t *testing.T, expectedPath, ssePayload string) *httptest.Server {
	t.Helper()
	return httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		if r.Method != http.MethodPost {
			t.Errorf("expected POST, got %s", r.Method)
			return
		}
		if r.URL.Path != expectedPath {
			t.Errorf("expected path=%s, got %s", expectedPath, r.URL.Path)
			return
		}
		if got := r.Header.Get("Authorization"); got != "Bearer test-key" {
			t.Errorf("expected Authorization=Bearer test-key, got %q", got)
			return
		}
		if got := r.Header.Get("Content-Type"); !strings.HasPrefix(got, "application/json") {
			t.Errorf("expected Content-Type to start with application/json, got %q", got)
			return
		}
		if got := r.Header.Get("Accept"); got != "text/event-stream" {
			t.Errorf("expected Accept=text/event-stream, got %q", got)
			return
		}
		w.Header().Set("Content-Type", "text/event-stream")
		_, _ = io.WriteString(w, ssePayload)
	}))
}

func newGPUStackForTest(baseURL string) *GPUStackModel {
	return NewGPUStackModel(
		map[string]string{"default": baseURL},
		URLSuffix{
			Chat: "v1/chat/completions", Models: "v1/models", Embedding: "v1/embeddings",
			Rerank: "v1/rerank", ASR: "v1/audio/transcriptions", TTS: "v1/audio/speech",
		},
	)
}

const gpustackEmbeddingsPath = "/v1/embeddings"

func TestGPUStackName(t *testing.T) {
	if got := newGPUStackForTest("http://unused").Name(); got != "gpustack" {
		t.Errorf("Name()=%q, want %q", got, "gpustack")
	}
}

func TestGPUStackFactory(t *testing.T) {
	driver, err := NewModelFactory().CreateModelDriver("GPUStack", map[string]string{"default": "http://unused"}, URLSuffix{})
	if err != nil {
		t.Fatalf("CreateModelDriver: %v", err)
	}
	if _, ok := driver.(*GPUStackModel); !ok {
		t.Fatalf("driver type=%T, want *GPUStackModel", driver)
	}
}

func TestGPUStackChatHappyPath(t *testing.T) {
	withSSRFBypass(t)
	srv := newGPUStackServer(t, "/v1/chat/completions", func(t *testing.T, body map[string]interface{}, w http.ResponseWriter) {
		if body["model"] != "qwen3-8b" {
			t.Errorf("model=%v", body["model"])
		}
		if body["stream"] != false {
			t.Errorf("stream=%v want false", body["stream"])
		}
		_ = json.NewEncoder(w).Encode(map[string]interface{}{
			"choices": []map[string]interface{}{{
				"message": map[string]interface{}{"content": "pong"},
			}},
		})
	})
	defer srv.Close()

	apiKey := "test-key"
	ctx := t.Context()
	resp, err := newGPUStackForTest(srv.URL).ChatWithMessages(
		ctx,
		"qwen3-8b",
		[]Message{{Role: "user", Content: "ping"}},
		&APIConfig{ApiKey: &apiKey}, nil, nil,
	)
	if err != nil {
		t.Fatalf("Chat: %v", err)
	}
	if resp.Answer == nil || *resp.Answer != "pong" {
		t.Errorf("Answer=%v", resp.Answer)
	}
	if resp.ReasonContent == nil || *resp.ReasonContent != "" {
		t.Errorf("ReasonContent=%v want empty", resp.ReasonContent)
	}
}

func TestGPUStackChatExtractsReasoningContent(t *testing.T) {
	withSSRFBypass(t)
	srv := newGPUStackServer(t, "/v1/chat/completions", func(t *testing.T, body map[string]interface{}, w http.ResponseWriter) {
		_ = json.NewEncoder(w).Encode(map[string]interface{}{
			"choices": []map[string]interface{}{{
				"message": map[string]interface{}{
					"role":              "assistant",
					"content":           "12",
					"reasoning_content": "0.15 * 80 = 12",
				},
			}},
		})
	})
	defer srv.Close()

	apiKey := "test-key"
	ctx := t.Context()
	resp, err := newGPUStackForTest(srv.URL).ChatWithMessages(
		ctx,
		"qwen3-32b",
		[]Message{{Role: "user", Content: "15% of 80?"}},
		&APIConfig{ApiKey: &apiKey}, nil, nil,
	)
	if err != nil {
		t.Fatalf("Chat: %v", err)
	}
	if *resp.Answer != "12" {
		t.Errorf("Answer=%q", *resp.Answer)
	}
	if *resp.ReasonContent != "0.15 * 80 = 12" {
		t.Errorf("ReasonContent=%q", *resp.ReasonContent)
	}
}

func TestGPUStackChatForwardsDocumentedFields(t *testing.T) {
	withSSRFBypass(t)
	srv := newGPUStackServer(t, "/v1/chat/completions", func(t *testing.T, body map[string]interface{}, w http.ResponseWriter) {
		for _, k := range []string{"model", "messages", "stream", "temperature", "top_p", "stop"} {
			if _, present := body[k]; !present {
				t.Errorf("documented field %q missing from request body", k)
			}
		}
		_ = json.NewEncoder(w).Encode(map[string]interface{}{
			"choices": []map[string]interface{}{{
				"message": map[string]interface{}{"content": "ok"},
			}},
		})
	})
	defer srv.Close()

	apiKey := "test-key"
	mt := 64
	temp := 0.5
	topP := 0.95
	stop := []string{"END"}
	ctx := t.Context()
	_, err := newGPUStackForTest(srv.URL).ChatWithMessages(
		ctx,
		"qwen3-8b",
		[]Message{{Role: "user", Content: "x"}},
		&APIConfig{ApiKey: &apiKey},
		&ChatConfig{MaxTokens: &mt, Temperature: &temp, TopP: &topP, Stop: &stop},
		nil,
	)
	if err != nil {
		t.Fatalf("Chat: %v", err)
	}
}

func TestGPUStackChatAllowsEmptyAPIKey(t *testing.T) {
	withSSRFBypass(t)
	ctx := t.Context()
	_, err := newGPUStackForTest("http://unused").ChatWithMessages(
		ctx,
		"qwen3-8b",
		[]Message{{Role: "user", Content: "x"}},
		&APIConfig{}, nil, nil,
	)
	if err == nil || strings.Contains(err.Error(), "api key is required") {
		t.Errorf("self-hosted model should not require api key, got %v", err)
	}
}

func TestGPUStackChatRequiresModelName(t *testing.T) {
	withSSRFBypass(t)
	apiKey := "test-key"
	ctx := t.Context()
	_, err := newGPUStackForTest("http://unused").ChatWithMessages(
		ctx,
		"",
		[]Message{{Role: "user", Content: "x"}},
		&APIConfig{ApiKey: &apiKey}, nil, nil,
	)
	if err == nil || !strings.Contains(err.Error(), "model name is required") {
		t.Errorf("expected model-name error, got %v", err)
	}
}

func TestGPUStackChatRequiresMessages(t *testing.T) {
	withSSRFBypass(t)
	apiKey := "test-key"
	ctx := t.Context()
	_, err := newGPUStackForTest("http://unused").ChatWithMessages(
		ctx,
		"qwen3-8b", nil, &APIConfig{ApiKey: &apiKey}, nil, nil,
	)
	if err == nil || !strings.Contains(err.Error(), "messages is empty") {
		t.Errorf("expected messages-empty error, got %v", err)
	}
}

func TestGPUStackChatRejectsHTTPError(t *testing.T) {
	withSSRFBypass(t)
	srv := newGPUStackServer(t, "/v1/chat/completions", func(t *testing.T, body map[string]interface{}, w http.ResponseWriter) {
		w.WriteHeader(http.StatusUnauthorized)
		_, _ = w.Write([]byte(`{"error":"unauthorized"}`))
	})
	defer srv.Close()

	apiKey := "test-key"
	ctx := t.Context()
	_, err := newGPUStackForTest(srv.URL).ChatWithMessages(
		ctx,
		"qwen3-8b",
		[]Message{{Role: "user", Content: "x"}},
		&APIConfig{ApiKey: &apiKey}, nil, nil,
	)
	if err == nil || !strings.Contains(err.Error(), "401") {
		t.Errorf("expected 401 propagated, got %v", err)
	}
}

func TestGPUStackChatRequiresBaseURL(t *testing.T) {
	withSSRFBypass(t)
	model := NewGPUStackModel(map[string]string{}, URLSuffix{Chat: "v1/chat/completions"})
	apiKey := "test-key"
	ctx := t.Context()
	_, err := model.ChatWithMessages(
		ctx,
		"qwen3-8b",
		[]Message{{Role: "user", Content: "x"}},
		&APIConfig{ApiKey: &apiKey}, nil, nil,
	)
	if err == nil || !strings.Contains(err.Error(), "no base URL configured") {
		t.Errorf("expected base-URL error, got %v", err)
	}
}

func TestGPUStackStreamHappyPath(t *testing.T) {
	withSSRFBypass(t)
	srv := newGPUStackSSEServer(t, "/v1/chat/completions",
		`data: {"choices":[{"index":0,"delta":{"role":"assistant"}}]}`+"\n"+
			`data: {"choices":[{"index":0,"delta":{"content":"Hello"}}]}`+"\n"+
			`data: {"choices":[{"index":0,"delta":{"content":" world"},"finish_reason":"stop"}]}`+"\n"+
			`data: [DONE]`+"\n",
	)
	defer srv.Close()

	apiKey := "test-key"
	var chunks []string
	var sawDone bool
	ctx := t.Context()
	err := newGPUStackForTest(srv.URL).ChatStreamlyWithSender(
		ctx,
		"qwen3-8b",
		[]Message{{Role: "user", Content: "hi"}},
		&APIConfig{ApiKey: &apiKey}, nil, nil,
		func(c *string, _ *string) error {
			if c == nil {
				return nil
			}
			if *c == "[DONE]" {
				sawDone = true
				return nil
			}
			chunks = append(chunks, *c)
			return nil
		},
	)
	if err != nil {
		t.Fatalf("stream: %v", err)
	}
	if strings.Join(chunks, "") != "Hello world" {
		t.Errorf("content=%v", chunks)
	}
	if !sawDone {
		t.Error("expected [DONE] sentinel")
	}
}

func TestGPUStackStreamExtractsReasoningContent(t *testing.T) {
	withSSRFBypass(t)
	srv := newGPUStackSSEServer(t, "/v1/chat/completions",
		`data: {"choices":[{"index":0,"delta":{"role":"assistant"}}]}`+"\n"+
			`data: {"choices":[{"index":0,"delta":{"reasoning_content":"think "}}]}`+"\n"+
			`data: {"choices":[{"index":0,"delta":{"content":"answer"},"finish_reason":"stop"}]}`+"\n"+
			`data: [DONE]`+"\n",
	)
	defer srv.Close()

	apiKey := "test-key"
	var content, reasoning []string
	ctx := t.Context()
	err := newGPUStackForTest(srv.URL).ChatStreamlyWithSender(
		ctx,
		"qwen3-32b",
		[]Message{{Role: "user", Content: "x"}},
		&APIConfig{ApiKey: &apiKey}, nil, nil,
		func(c *string, r *string) error {
			if r != nil && *r != "" {
				reasoning = append(reasoning, *r)
			}
			if c != nil && *c != "" && *c != "[DONE]" {
				content = append(content, *c)
			}
			return nil
		},
	)
	if err != nil {
		t.Fatalf("stream: %v", err)
	}
	if strings.Join(reasoning, "") != "think " {
		t.Errorf("reasoning=%q", strings.Join(reasoning, ""))
	}
	if strings.Join(content, "") != "answer" {
		t.Errorf("content=%q", strings.Join(content, ""))
	}
}

func TestGPUStackStreamRejectsExplicitFalse(t *testing.T) {
	withSSRFBypass(t)
	apiKey := "test-key"
	stream := false
	ctx := t.Context()
	err := newGPUStackForTest("http://unused").ChatStreamlyWithSender(
		ctx,
		"qwen3-8b",
		[]Message{{Role: "user", Content: "x"}},
		&APIConfig{ApiKey: &apiKey},
		&ChatConfig{Stream: &stream},
		nil,
		func(*string, *string) error { return nil },
	)
	if err == nil || !strings.Contains(err.Error(), "stream must be true") {
		t.Errorf("expected stream-true guard, got %v", err)
	}
}

func TestGPUStackStreamRequiresSender(t *testing.T) {
	withSSRFBypass(t)
	apiKey := "test-key"
	ctx := t.Context()
	err := newGPUStackForTest("http://unused").ChatStreamlyWithSender(
		ctx,
		"qwen3-8b",
		[]Message{{Role: "user", Content: "x"}},
		&APIConfig{ApiKey: &apiKey}, nil, nil, nil,
	)
	if err == nil || !strings.Contains(err.Error(), "sender is required") {
		t.Errorf("expected sender-required error, got %v", err)
	}
}

func TestGPUStackStreamFailsWithoutTerminal(t *testing.T) {
	withSSRFBypass(t)
	srv := newGPUStackSSEServer(t, "/v1/chat/completions",
		`data: {"choices":[{"delta":{"content":"half"}}]}`+"\n",
	)
	defer srv.Close()

	apiKey := "test-key"
	ctx := t.Context()
	err := newGPUStackForTest(srv.URL).ChatStreamlyWithSender(
		ctx,
		"qwen3-8b",
		[]Message{{Role: "user", Content: "x"}},
		&APIConfig{ApiKey: &apiKey}, nil, nil,
		func(*string, *string) error { return nil },
	)
	if err == nil || !strings.Contains(err.Error(), "stream ended before") {
		t.Errorf("expected truncation error, got %v", err)
	}
}

func TestGPUStackStreamRejectsMalformedFrame(t *testing.T) {
	withSSRFBypass(t)
	srv := newGPUStackSSEServer(t, "/v1/chat/completions",
		`data: {"choices":[{"delta":{"content":"ok"}}]}`+"\n"+
			`data: {this is not valid json}`+"\n",
	)
	defer srv.Close()

	apiKey := "test-key"
	ctx := t.Context()
	err := newGPUStackForTest(srv.URL).ChatStreamlyWithSender(
		ctx,
		"qwen3-8b",
		[]Message{{Role: "user", Content: "x"}},
		&APIConfig{ApiKey: &apiKey}, nil, nil,
		func(*string, *string) error { return nil },
	)
	if err == nil || !strings.Contains(err.Error(), "invalid SSE event") {
		t.Errorf("expected invalid-SSE error, got %v", err)
	}
}

func TestGPUStackStreamSurfacesUpstreamError(t *testing.T) {
	withSSRFBypass(t)
	srv := newGPUStackSSEServer(t, "/v1/chat/completions",
		`data: {"choices":[{"delta":{"content":"partial "}}]}`+"\n"+
			`data: {"error":{"message":"oom","type":"runtime_error"}}`+"\n",
	)
	defer srv.Close()

	apiKey := "test-key"
	ctx := t.Context()
	err := newGPUStackForTest(srv.URL).ChatStreamlyWithSender(
		ctx,
		"qwen3-8b",
		[]Message{{Role: "user", Content: "x"}},
		&APIConfig{ApiKey: &apiKey}, nil, nil,
		func(*string, *string) error { return nil },
	)
	if err == nil || !strings.Contains(err.Error(), "upstream stream error") {
		t.Errorf("expected upstream-error surfacing, got %v", err)
	}
}

func TestGPUStackListModelsHappyPath(t *testing.T) {
	withSSRFBypass(t)
	ctx := t.Context()
	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		if r.Method != http.MethodGet {
			t.Errorf("method=%s want GET", r.Method)
		}
		if r.URL.Path != "/v1/models" {
			t.Errorf("path=%s", r.URL.Path)
		}
		if got := r.Header.Get("Authorization"); got != "Bearer test-key" {
			t.Errorf("Authorization=%q", got)
		}
		_ = json.NewEncoder(w).Encode(map[string]interface{}{
			"data": []map[string]interface{}{
				{"id": "qwen3-8b"},
				{"id": "qwen3-32b"},
			},
		})
	}))
	defer srv.Close()

	apiKey := "test-key"
	model := newGPUStackForTest(srv.URL)
	models, err := model.ListModels(ctx, &APIConfig{ApiKey: &apiKey})
	if err != nil {
		t.Fatalf("ListModels: %v", err)
	}
	if joinModelNames(models, ",") != "qwen3-8b,qwen3-32b" {
		t.Errorf("models=%v", models)
	}
	if err := model.CheckConnection(ctx, &APIConfig{ApiKey: &apiKey}); err != nil {
		t.Fatalf("CheckConnection: %v", err)
	}
}

// newGPUStackCategoryServer serves /v1/models like GPUStack: every route without
// a filter, or only the routes carrying one of the requested categories.
func newGPUStackCategoryServer(t *testing.T, routes map[string][]string) *httptest.Server {
	t.Helper()
	names := make([]string, 0, len(routes))
	for name := range routes {
		names = append(names, name)
	}
	sort.Strings(names)
	return httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		if r.URL.Path != "/v1/models" {
			t.Errorf("path=%s", r.URL.Path)
		}
		requested := r.URL.Query()["categories"]
		data := []map[string]interface{}{}
		for _, name := range names {
			if len(requested) == 0 || slices.Contains(routes[name], requested[0]) {
				data = append(data, map[string]interface{}{"id": name})
			}
		}
		_ = json.NewEncoder(w).Encode(map[string]interface{}{"data": data})
	}))
}

func gpustackModelTypesByName(t *testing.T, baseURL string) map[string][]string {
	t.Helper()
	apiKey := "test-key"
	listed, err := newGPUStackForTest(baseURL).ListModels(t.Context(), &APIConfig{ApiKey: &apiKey})
	if err != nil {
		t.Fatalf("ListModels: %v", err)
	}
	types := make(map[string][]string, len(listed))
	for _, model := range listed {
		types[model.Name] = model.ModelTypes
	}
	return types
}

func TestGPUStackListModelsUsesCategories(t *testing.T) {
	withSSRFBypass(t)
	srv := newGPUStackCategoryServer(t, map[string][]string{
		"assistant":           {"llm"},
		"kb-encoder":          {"embedding"},
		"doc-sorter":          {"reranker"},
		"voice-in":            {"speech_to_text"},
		"voice-out":           {"text_to_speech"},
		"qwen2.5-vl":          {"llm"},
		"rerank-as-embedding": {"embedding"},
		"whisper-small":       {"llm"},
		"bge-as-rerank":       {"reranker"},
		"painter":             {"image"},
		"no-category":         {},
		"bge-m3-route":        {},
	})
	defer srv.Close()

	got := gpustackModelTypesByName(t, srv.URL)
	want := map[string][]string{
		"assistant":  {modelTypeChat},
		"kb-encoder": {modelTypeEmbedding},
		"doc-sorter": {modelTypeRerank},
		"voice-in":   {modelTypeASR},
		"voice-out":  {modelTypeTTS},
		// Vision has no GPUStack category, so it still comes from the name.
		"qwen2.5-vl": {modelTypeChat, modelTypeVision},
		// A specific category beats a name that suggests something else.
		"rerank-as-embedding": {modelTypeEmbedding},
		"bge-as-rerank":       {modelTypeRerank},
		// "llm" is GPUStack's default for unknown architectures, so the name wins.
		"whisper-small": {modelTypeASR},
		// Routes without categories fall back to the name.
		"no-category":  {modelTypeChat},
		"bge-m3-route": {modelTypeEmbedding},
	}
	if !reflect.DeepEqual(got, want) {
		t.Errorf("types=%v\nwant %v", got, want)
	}
}

// CosyVoice has no config.json, so GPUStack files it under "llm" by default.
func TestGPUStackListModelsDetectsTTSFromVoices(t *testing.T) {
	withSSRFBypass(t)
	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		data := []map[string]interface{}{{"id": "plain"}, {"id": "voice-out"}}
		switch r.URL.Query().Get("categories") {
		case "":
			if r.URL.Query().Get("with_meta") == "true" {
				data[1]["meta"] = map[string]interface{}{"voices": []string{"Chinese Female"}}
			}
		case "llm":
		default:
			data = nil
		}
		_ = json.NewEncoder(w).Encode(map[string]interface{}{"data": data})
	}))
	defer srv.Close()

	got := gpustackModelTypesByName(t, srv.URL)
	want := map[string][]string{"plain": {modelTypeChat}, "voice-out": {modelTypeTTS}}
	if !reflect.DeepEqual(got, want) {
		t.Errorf("types=%v, want %v", got, want)
	}
}

func TestGPUStackListModelsReadsContextLengthFromMeta(t *testing.T) {
	withSSRFBypass(t)
	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		data := []map[string]interface{}{{"id": "served"}, {"id": "unknown"}}
		if r.URL.Query().Get("with_meta") == "true" {
			data[0]["meta"] = map[string]interface{}{"max_model_len": 8192}
		}
		if r.URL.Query().Has("categories") {
			data = nil
		}
		_ = json.NewEncoder(w).Encode(map[string]interface{}{"data": data})
	}))
	defer srv.Close()

	apiKey := "test-key"
	listed, err := newGPUStackForTest(srv.URL).ListModels(t.Context(), &APIConfig{ApiKey: &apiKey})
	if err != nil {
		t.Fatalf("ListModels: %v", err)
	}
	if len(listed) != 2 {
		t.Fatalf("listed=%v", listed)
	}
	if listed[0].ContextLength == nil || *listed[0].ContextLength != 8192 {
		t.Errorf("served context length=%v, want 8192", listed[0].ContextLength)
	}
	if listed[1].ContextLength != nil {
		t.Errorf("unknown context length=%v, want nil", *listed[1].ContextLength)
	}
}

func TestGPUStackListModelsSingleCategoryCluster(t *testing.T) {
	withSSRFBypass(t)
	srv := newGPUStackCategoryServer(t, map[string][]string{"a": {"embedding"}, "b": {"embedding"}})
	defer srv.Close()

	got := gpustackModelTypesByName(t, srv.URL)
	want := map[string][]string{"a": {modelTypeEmbedding}, "b": {modelTypeEmbedding}}
	if !reflect.DeepEqual(got, want) {
		t.Errorf("types=%v, want %v", got, want)
	}
}

func TestGPUStackListModelsIgnoresUnappliedCategoryFilter(t *testing.T) {
	withSSRFBypass(t)
	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		_ = json.NewEncoder(w).Encode(map[string]interface{}{
			"data": []map[string]interface{}{{"id": "bge-m3"}, {"id": "bge-reranker-v2-m3"}, {"id": "qwen3-8b"}},
		})
	}))
	defer srv.Close()

	got := gpustackModelTypesByName(t, srv.URL)
	want := map[string][]string{
		"bge-m3":             {modelTypeEmbedding},
		"bge-reranker-v2-m3": {modelTypeRerank},
		"qwen3-8b":           {modelTypeChat},
	}
	if !reflect.DeepEqual(got, want) {
		t.Errorf("types=%v, want %v", got, want)
	}
}

func TestGPUStackListModelsSurvivesCategoryLookupFailure(t *testing.T) {
	withSSRFBypass(t)
	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		if r.URL.Query().Has("categories") {
			http.Error(w, "boom", http.StatusInternalServerError)
			return
		}
		_ = json.NewEncoder(w).Encode(map[string]interface{}{"data": []map[string]interface{}{{"id": "bge-m3"}}})
	}))
	defer srv.Close()

	got := gpustackModelTypesByName(t, srv.URL)
	if !reflect.DeepEqual(got, map[string][]string{"bge-m3": {modelTypeEmbedding}}) {
		t.Errorf("types=%v", got)
	}
}

func TestGPUStackListModelsReportsAuthFailure(t *testing.T) {
	withSSRFBypass(t)
	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		http.Error(w, `{"code":401,"message":"Invalid authentication credentials"}`, http.StatusUnauthorized)
	}))
	defer srv.Close()

	apiKey := "wrong"
	_, err := newGPUStackForTest(srv.URL).ListModels(t.Context(), &APIConfig{ApiKey: &apiKey})
	if err == nil || !strings.Contains(err.Error(), "401") {
		t.Errorf("err=%v, want the 401 surfaced", err)
	}
}

func TestGPUStackEmbedRecordsUsage(t *testing.T) {
	withSSRFBypass(t)
	srv := newGPUStackServer(t, gpustackEmbeddingsPath, func(t *testing.T, body map[string]interface{}, w http.ResponseWriter) {
		_ = json.NewEncoder(w).Encode(map[string]interface{}{
			"id":    "embd-1",
			"data":  []map[string]interface{}{{"embedding": []float64{0.1}, "index": 0}},
			"usage": map[string]interface{}{"prompt_tokens": 8, "total_tokens": 8},
		})
	})
	defer srv.Close()

	model := "bge-m3"
	apiKey := "test-key"
	usage := &common.ModelUsage{}
	_, err := configuredGPUStackForTest(t, srv.URL).Embed(t.Context(), &model, EmbedRequest{Texts: []string{"hello"}}, &APIConfig{ApiKey: &apiKey}, nil, usage)
	if err != nil {
		t.Fatalf("Embed: %v", err)
	}
	if usage.TotalTokens != 8 || usage.Type != "embedding" || usage.RequestID != "embd-1" {
		t.Errorf("usage=%+v", usage)
	}
}

func TestGPUStackListModelsAllowsEmptyAPIKey(t *testing.T) {
	withSSRFBypass(t)
	ctx := t.Context()
	_, err := newGPUStackForTest("http://unused").ListModels(ctx, &APIConfig{})
	if err == nil || strings.Contains(err.Error(), "api key is required") {
		t.Errorf("self-hosted model should not require api key, got %v", err)
	}
}

// TestGPUStackEmbedHappyPath verifies request shape and dimensions on v1/embeddings.
func TestGPUStackEmbedHappyPath(t *testing.T) {
	withSSRFBypass(t)
	for _, basePath := range []string{"", "/v1/"} {
		t.Run("base="+basePath, func(t *testing.T) {
			srv := newGPUStackServer(t, gpustackEmbeddingsPath, func(t *testing.T, body map[string]interface{}, w http.ResponseWriter) {
				if body["model"] != "bge-m3" {
					t.Errorf("model=%v", body["model"])
				}
				if body["dimensions"] != float64(512) {
					t.Errorf("dimensions=%v, want 512", body["dimensions"])
				}
				inputs, ok := body["input"].([]interface{})
				if !ok || len(inputs) != 2 {
					t.Errorf("input=%v, want 2-element array", body["input"])
				}
				_ = json.NewEncoder(w).Encode(map[string]interface{}{
					"data": []map[string]interface{}{
						{"embedding": []float64{0.2, 0.2}, "index": 1},
						{"embedding": []float64{0.1, 0.2}, "index": 0},
					},
				})
			})
			defer srv.Close()

			apiKey := "test-key"
			model := "bge-m3"
			ctx := t.Context()
			vecs, err := configuredGPUStackForTest(t, srv.URL+basePath).Embed(ctx, &model, EmbedRequest{Texts: []string{"a", "b"}}, &APIConfig{ApiKey: &apiKey}, &EmbeddingConfig{Dimension: 512}, nil)
			if err != nil {
				t.Fatalf("Embed: %v", err)
			}
			if len(vecs) != 2 {
				t.Fatalf("len(vecs)=%d, want 2", len(vecs))
			}
			if vecs[0].Index != 0 || vecs[0].Embedding[0] != 0.1 || vecs[1].Index != 1 || vecs[1].Embedding[0] != 0.2 {
				t.Errorf("vecs=%+v", vecs)
			}
		})
	}
}

// TestGPUStackEmbedReordersByIndex verifies out-of-order response indices are mapped correctly.
func TestGPUStackEmbedReordersByIndex(t *testing.T) {
	withSSRFBypass(t)
	srv := newGPUStackServer(t, gpustackEmbeddingsPath, func(t *testing.T, _ map[string]interface{}, w http.ResponseWriter) {
		_ = json.NewEncoder(w).Encode(map[string]interface{}{
			"data": []map[string]interface{}{
				{"embedding": []float64{2}, "index": 2},
				{"embedding": []float64{0}, "index": 0},
				{"embedding": []float64{1}, "index": 1},
			},
		})
	})
	defer srv.Close()

	apiKey := "test-key"
	model := "bge-m3"
	ctx := t.Context()
	vecs, err := newGPUStackForTest(srv.URL).Embed(ctx, &model, EmbedRequest{Texts: []string{"a", "b", "c"}}, &APIConfig{ApiKey: &apiKey}, nil, nil)
	if err != nil {
		t.Fatalf("Embed: %v", err)
	}
	for i, v := range vecs {
		if v.Index != i || v.Embedding[0] != float64(i) {
			t.Errorf("slot %d = %+v, want Embedding=[%d] Index=%d", i, v, i, i)
		}
	}
}

// TestGPUStackEmbedEmptyInputShortCircuits avoids HTTP when texts is empty.
func TestGPUStackEmbedEmptyInputShortCircuits(t *testing.T) {
	withSSRFBypass(t)
	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
		t.Error("Embed([]) made an unexpected HTTP call")
		w.WriteHeader(http.StatusInternalServerError)
	}))
	defer srv.Close()

	apiKey := "test-key"
	model := "bge-m3"
	ctx := t.Context()
	vecs, err := newGPUStackForTest(srv.URL).Embed(
		ctx, &model, EmbedRequest{Texts: []string{}}, &APIConfig{ApiKey: &apiKey}, nil, nil)
	if err != nil {
		t.Fatalf("Embed([]): %v", err)
	}
	if len(vecs) != 0 {
		t.Errorf("len(vecs)=%d, want 0", len(vecs))
	}
}

// TestGPUStackEmbedRequiresAPIKey rejects requests without an API key.
func TestGPUStackEmbedAllowsEmptyAPIKey(t *testing.T) {
	withSSRFBypass(t)
	ctx := t.Context()
	model := "bge-m3"
	_, err := newGPUStackForTest("http://unused").Embed(ctx, &model, EmbedRequest{Texts: []string{"a"}}, &APIConfig{}, nil, nil)
	if err == nil || strings.Contains(err.Error(), "api key is required") {
		t.Errorf("self-hosted model should not require api key, got %v", err)
	}
}

// TestGPUStackEmbedRejectsDuplicateIndex errors on duplicate response indices.
func TestGPUStackEmbedRejectsDuplicateIndex(t *testing.T) {
	withSSRFBypass(t)
	srv := newGPUStackServer(t, gpustackEmbeddingsPath, func(t *testing.T, _ map[string]interface{}, w http.ResponseWriter) {
		_ = json.NewEncoder(w).Encode(map[string]interface{}{
			"data": []map[string]interface{}{
				{"embedding": []float64{0.1}, "index": 0},
				{"embedding": []float64{0.2}, "index": 0},
			},
		})
	})
	defer srv.Close()

	apiKey := "test-key"
	model := "bge-m3"
	ctx := t.Context()
	_, err := newGPUStackForTest(srv.URL).Embed(ctx, &model, EmbedRequest{Texts: []string{"a", "b"}}, &APIConfig{ApiKey: &apiKey}, nil, nil)
	if err == nil || !strings.Contains(err.Error(), "duplicate") {
		t.Errorf("expected duplicate-index error, got %v", err)
	}
}

// TestGPUStackEmbedRejectsOutOfRangeIndex errors when index exceeds input length.
func TestGPUStackEmbedRejectsOutOfRangeIndex(t *testing.T) {
	withSSRFBypass(t)
	srv := newGPUStackServer(t, gpustackEmbeddingsPath, func(t *testing.T, _ map[string]interface{}, w http.ResponseWriter) {
		_ = json.NewEncoder(w).Encode(map[string]interface{}{
			"data": []map[string]interface{}{
				{"embedding": []float64{0.1}, "index": 2},
			},
		})
	})
	defer srv.Close()

	apiKey := "test-key"
	model := "bge-m3"
	ctx := t.Context()
	_, err := newGPUStackForTest(srv.URL).Embed(ctx, &model, EmbedRequest{Texts: []string{"a", "b"}}, &APIConfig{ApiKey: &apiKey}, nil, nil)
	if err == nil || !strings.Contains(err.Error(), "out of range") {
		t.Errorf("expected out-of-range error, got %v", err)
	}
}

// TestGPUStackEmbedRejectsMissingIndex errors when index is omitted from response.
func TestGPUStackEmbedRejectsMissingIndex(t *testing.T) {
	withSSRFBypass(t)
	srv := newGPUStackServer(t, gpustackEmbeddingsPath, func(t *testing.T, _ map[string]interface{}, w http.ResponseWriter) {
		_ = json.NewEncoder(w).Encode(map[string]interface{}{
			"data": []map[string]interface{}{
				{"embedding": []float64{0.1}},
			},
		})
	})
	defer srv.Close()

	apiKey := "test-key"
	model := "bge-m3"
	ctx := t.Context()
	_, err := newGPUStackForTest(srv.URL).Embed(ctx, &model, EmbedRequest{Texts: []string{"a"}}, &APIConfig{ApiKey: &apiKey}, nil, nil)
	if err == nil || !strings.Contains(err.Error(), "missing embedding index") {
		t.Errorf("expected missing-index error, got %v", err)
	}
}

// TestGPUStackEmbedRejectsEmptyVector errors when the API returns a zero-length vector.
func TestGPUStackEmbedRejectsEmptyVector(t *testing.T) {
	withSSRFBypass(t)
	srv := newGPUStackServer(t, gpustackEmbeddingsPath, func(t *testing.T, _ map[string]interface{}, w http.ResponseWriter) {
		_ = json.NewEncoder(w).Encode(map[string]interface{}{
			"data": []map[string]interface{}{
				{"embedding": []float64{}, "index": 0},
			},
		})
	})
	defer srv.Close()

	apiKey := "test-key"
	model := "bge-m3"
	ctx := t.Context()
	_, err := newGPUStackForTest(srv.URL).Embed(ctx, &model, EmbedRequest{Texts: []string{"a"}}, &APIConfig{ApiKey: &apiKey}, nil, nil)
	if err == nil || !strings.Contains(err.Error(), "empty embedding vector") {
		t.Errorf("expected empty-vector error, got %v", err)
	}
}

// TestGPUStackEmbedRejectsMissingSlot errors when a response index is never returned.
func TestGPUStackEmbedRejectsMissingSlot(t *testing.T) {
	withSSRFBypass(t)
	srv := newGPUStackServer(t, gpustackEmbeddingsPath, func(t *testing.T, _ map[string]interface{}, w http.ResponseWriter) {
		_ = json.NewEncoder(w).Encode(map[string]interface{}{
			"data": []map[string]interface{}{
				{"embedding": []float64{0.1}, "index": 0},
			},
		})
	})
	defer srv.Close()

	apiKey := "test-key"
	model := "bge-m3"
	ctx := t.Context()
	_, err := newGPUStackForTest(srv.URL).Embed(ctx, &model, EmbedRequest{Texts: []string{"a", "b"}}, &APIConfig{ApiKey: &apiKey}, nil, nil)
	if err == nil || !strings.Contains(err.Error(), "missing embedding for input index") {
		t.Errorf("expected missing-slot error, got %v", err)
	}
}

func TestGPUStackUnsupportedMethods(t *testing.T) {
	withSSRFBypass(t)
	ctx := t.Context()
	m := newGPUStackForTest("http://unused")
	model := "x"

	if _, err := m.Balance(ctx, &APIConfig{}); err == nil || !strings.Contains(err.Error(), "no such method") {
		t.Errorf("Balance: %v", err)
	}

	if _, err := m.OCRFile(ctx, &model, nil, &model, &APIConfig{}, nil, nil); err == nil || !strings.Contains(err.Error(), "no such method") {
		t.Errorf("OCRFile: %v", err)
	}
}