diff --git a/conf/models/mistral.json b/conf/models/mistral.json index be9cbb1861..1454922e80 100644 --- a/conf/models/mistral.json +++ b/conf/models/mistral.json @@ -89,6 +89,20 @@ "chat" ] }, + { + "name": "magistral-medium-latest", + "max_tokens": 40000, + "model_types": [ + "chat" + ] + }, + { + "name": "magistral-small-latest", + "max_tokens": 40000, + "model_types": [ + "chat" + ] + }, { "name": "mistral-embed", "max_tokens": 8192, diff --git a/internal/entity/models/mistral.go b/internal/entity/models/mistral.go index 1b526a8776..e37a3998f4 100644 --- a/internal/entity/models/mistral.go +++ b/internal/entity/models/mistral.go @@ -195,18 +195,80 @@ func (m *MistralModel) ChatWithMessages(modelName string, messages []Message, ap return nil, fmt.Errorf("invalid message format") } - content, ok := messageMap["content"].(string) - if !ok { - return nil, fmt.Errorf("invalid content format") + content, reasonContent, err := extractMistralContent(messageMap["content"]) + if err != nil { + return nil, err } - emptyReason := "" return &ChatResponse{ Answer: &content, - ReasonContent: &emptyReason, + ReasonContent: &reasonContent, }, nil } +// extractMistralContent normalizes the two shapes Mistral can return in +// choices[0].message.content. +// +// 1. Plain string. The historical shape, used by every non-reasoning +// Mistral model (mistral-large, mistral-medium, ministral-*, etc.): +// +// "content": "Pong." +// +// 2. Structured array of typed parts. Used by the magistral reasoning +// family (magistral-small-*, magistral-medium-*) when the model +// actually produces a chain-of-thought: +// +// "content": [ +// {"type": "thinking", "thinking": [{"type": "text", "text": "..."}]}, +// {"type": "text", "text": "The final answer is ..."} +// ] +// +// The function concatenates the visible text parts into the assistant +// answer and the inner thinking text into the reasoning trace. Unknown +// part types are skipped rather than failing, so a new part shape from +// Mistral does not break the driver for tenants that don't use it. +func extractMistralContent(raw interface{}) (string, string, error) { + switch v := raw.(type) { + case string: + return v, "", nil + case []interface{}: + var answer, reasoning strings.Builder + for _, part := range v { + pm, ok := part.(map[string]interface{}) + if !ok { + continue + } + switch pm["type"] { + case "text": + if t, ok := pm["text"].(string); ok { + answer.WriteString(t) + } + case "thinking": + // thinking is an array of inner text parts; concatenate + // any inner element with a non-empty text field. + inner, ok := pm["thinking"].([]interface{}) + if !ok { + continue + } + for _, sub := range inner { + sm, ok := sub.(map[string]interface{}) + if !ok { + continue + } + if t, ok := sm["text"].(string); ok { + reasoning.WriteString(t) + } + } + } + } + return answer.String(), reasoning.String(), nil + case nil: + return "", "", nil + default: + return "", "", fmt.Errorf("mistral: unsupported content type %T", raw) + } +} + // ChatStreamlyWithSender sends messages and streams the response via the // sender function. The Mistral SSE stream uses the same shape as OpenAI: // "data:" lines carrying JSON events, with a final "[DONE]" line. diff --git a/internal/entity/models/mistral_test.go b/internal/entity/models/mistral_test.go index dc7f318e14..7f288faff0 100644 --- a/internal/entity/models/mistral_test.go +++ b/internal/entity/models/mistral_test.go @@ -572,3 +572,202 @@ func TestMistralEmbedRejectsHTTPError(t *testing.T) { t.Errorf("expected Mistral embeddings API error, got %v", err) } } + +// --- structured-content (magistral reasoning) tests --- + +// Regression net: the existing string-content path stays green for every +// non-reasoning Mistral model. +func TestMistralChatHandlesStringContent(t *testing.T) { + srv := newMistralServer(t, "/chat/completions", func(t *testing.T, _ map[string]interface{}, w http.ResponseWriter) { + _ = json.NewEncoder(w).Encode(map[string]interface{}{ + "choices": []map[string]interface{}{{"message": map[string]interface{}{ + "role": "assistant", + "content": "Pong.", + }}}, + }) + }) + defer srv.Close() + + m := newMistralForTest(srv.URL) + apiKey := "test-key" + resp, err := m.ChatWithMessages("ministral-3b-latest", + []Message{{Role: "user", Content: "ping"}}, + &APIConfig{ApiKey: &apiKey}, nil) + if err != nil { + t.Fatalf("Chat: %v", err) + } + if *resp.Answer != "Pong." { + t.Errorf("Answer=%q want %q", *resp.Answer, "Pong.") + } + if *resp.ReasonContent != "" { + t.Errorf("ReasonContent=%q want empty", *resp.ReasonContent) + } +} + +// New path: magistral with a non-trivial answer returns a structured +// content array. Two part types — `thinking` and `text` — must be +// concatenated into ReasonContent and Answer respectively. +// +// The fixture body is a trimmed copy of the actual response captured +// from api.mistral.ai/v1/chat/completions against magistral-medium-latest +// with the prompt "When do two trains meet?". +func TestMistralChatExtractsReasoningFromStructuredContent(t *testing.T) { + srv := newMistralServer(t, "/chat/completions", func(t *testing.T, _ map[string]interface{}, w http.ResponseWriter) { + _ = json.NewEncoder(w).Encode(map[string]interface{}{ + "choices": []map[string]interface{}{{"message": map[string]interface{}{ + "role": "assistant", + "content": []map[string]interface{}{ + { + "type": "thinking", + "thinking": []map[string]interface{}{ + {"type": "text", "text": "Combined speed is 150 mph. "}, + {"type": "text", "text": "300 / 150 = 2 hours."}, + }, + "closed": true, + }, + {"type": "text", "text": "They will meet after **2 hours**."}, + }, + }}}, + }) + }) + defer srv.Close() + + m := newMistralForTest(srv.URL) + apiKey := "test-key" + resp, err := m.ChatWithMessages("magistral-medium-latest", + []Message{{Role: "user", Content: "When do they meet?"}}, + &APIConfig{ApiKey: &apiKey}, nil) + if err != nil { + t.Fatalf("Chat: %v", err) + } + wantAnswer := "They will meet after **2 hours**." + wantReason := "Combined speed is 150 mph. 300 / 150 = 2 hours." + if *resp.Answer != wantAnswer { + t.Errorf("Answer=%q want %q", *resp.Answer, wantAnswer) + } + if *resp.ReasonContent != wantReason { + t.Errorf("ReasonContent=%q want %q", *resp.ReasonContent, wantReason) + } +} + +// magistral with a trivial answer that needed no reasoning returns the +// structured shape with only a `text` part. ReasonContent must be empty. +func TestMistralChatHandlesStructuredContentWithoutThinking(t *testing.T) { + srv := newMistralServer(t, "/chat/completions", func(t *testing.T, _ map[string]interface{}, w http.ResponseWriter) { + _ = json.NewEncoder(w).Encode(map[string]interface{}{ + "choices": []map[string]interface{}{{"message": map[string]interface{}{ + "role": "assistant", + "content": []map[string]interface{}{ + {"type": "text", "text": "12"}, + }, + }}}, + }) + }) + defer srv.Close() + + m := newMistralForTest(srv.URL) + apiKey := "test-key" + resp, err := m.ChatWithMessages("magistral-small-latest", + []Message{{Role: "user", Content: "15% of 80?"}}, + &APIConfig{ApiKey: &apiKey}, nil) + if err != nil { + t.Fatalf("Chat: %v", err) + } + if *resp.Answer != "12" { + t.Errorf("Answer=%q want %q", *resp.Answer, "12") + } + if *resp.ReasonContent != "" { + t.Errorf("ReasonContent=%q want empty (no thinking part)", *resp.ReasonContent) + } +} + +// Unknown part types must be skipped, not crash the driver. This makes +// the parser forward-compatible with new Mistral content variants +// (audio chunks, citations, etc.) that ragflow doesn't surface yet. +func TestMistralChatIgnoresUnknownContentPartTypes(t *testing.T) { + srv := newMistralServer(t, "/chat/completions", func(t *testing.T, _ map[string]interface{}, w http.ResponseWriter) { + _ = json.NewEncoder(w).Encode(map[string]interface{}{ + "choices": []map[string]interface{}{{"message": map[string]interface{}{ + "role": "assistant", + "content": []map[string]interface{}{ + {"type": "audio_url", "audio_url": "ignored://x"}, + {"type": "text", "text": "Hello"}, + {"type": "future_part_type", "blob": "?"}, + }, + }}}, + }) + }) + defer srv.Close() + + m := newMistralForTest(srv.URL) + apiKey := "test-key" + resp, err := m.ChatWithMessages("magistral-small-latest", + []Message{{Role: "user", Content: "x"}}, + &APIConfig{ApiKey: &apiKey}, nil) + if err != nil { + t.Fatalf("Chat: %v", err) + } + if *resp.Answer != "Hello" { + t.Errorf("Answer=%q want %q", *resp.Answer, "Hello") + } +} + +// Direct unit coverage of the helper, including the nil and bad-type +// edge cases that won't surface in the integration tests above. +func TestExtractMistralContent(t *testing.T) { + tests := []struct { + name string + input interface{} + wantAns string + wantReason string + wantErr bool + }{ + {"plain string", "hi", "hi", "", false}, + {"empty string", "", "", "", false}, + {"nil", nil, "", "", false}, + {"empty array", []interface{}{}, "", "", false}, + { + "text only", + []interface{}{ + map[string]interface{}{"type": "text", "text": "a"}, + map[string]interface{}{"type": "text", "text": "b"}, + }, + "ab", "", false, + }, + { + "thinking then text", + []interface{}{ + map[string]interface{}{ + "type": "thinking", + "thinking": []interface{}{ + map[string]interface{}{"type": "text", "text": "why "}, + map[string]interface{}{"type": "text", "text": "this"}, + }, + }, + map[string]interface{}{"type": "text", "text": "answer"}, + }, + "answer", "why this", false, + }, + {"unknown root type", 42, "", "", true}, + } + for _, tc := range tests { + t.Run(tc.name, func(t *testing.T) { + ans, reason, err := extractMistralContent(tc.input) + if tc.wantErr { + if err == nil { + t.Errorf("want error, got nil") + } + return + } + if err != nil { + t.Errorf("unexpected err: %v", err) + } + if ans != tc.wantAns { + t.Errorf("answer=%q want %q", ans, tc.wantAns) + } + if reason != tc.wantReason { + t.Errorf("reason=%q want %q", reason, tc.wantReason) + } + }) + } +}