RAGFlow is an agent-native database: a Retrieval-Augmented Generation (RAG) engine that grew into context infrastructure.
Go agent-harnessagent-native-databaseagentic-aiagentic-retrievalagentic-searchaiai-agentscontext-enginecontext-engineeringcontext-managementharness-engineeringknowledge-compilationragretrieval-augmented-generationretrieval-harnesssearch-harness
fix(sdk-messages): correct message API behavior (#21744)
Sbaaoui Idriss5e9f6415344b
diff --git a/internal/engine/elasticsearch/chunk.go b/internal/engine/elasticsearch/chunk.goindex f27dfef5ae..65b9b4efa6 100644--- a/internal/engine/elasticsearch/chunk.go+++ b/internal/engine/elasticsearch/chunk.go@@ -2324,6 +2324,13 @@ func buildBoolQueryFromConditionRaw(filter map[string]interface{}, kbIDs []strinif v == nil || v == "" {continue}+ if isMemoryIndex && k == "session_id_contains" {+ if text, ok := v.(string); ok {+ pattern := strings.NewReplacer(`\`, `\\`, "*", `\*`, "?", `\?`).Replace(text)+ filterClauses = append(filterClauses, map[string]interface{}{"wildcard": map[string]interface{}{"session_id": "*" + pattern + "*"}})+ }+ continue+ }if isMemoryIndex && k == "session_id" {if strVal, ok := v.(string); ok && strVal != "" {filterClauses = append(filterClauses, map[string]interface{}{diff --git a/internal/engine/elasticsearch/message_contract_test.go b/internal/engine/elasticsearch/message_contract_test.gonew file mode 100644index 0000000000..a45c0c9ca5--- /dev/null+++ b/internal/engine/elasticsearch/message_contract_test.go@@ -0,0 +1,30 @@+//+// Copyright 2026 The InfiniFlow Authors. All Rights Reserved.+//+// Licensed under the Apache License, Version 2.0 (the "License");+// you may not use this file except in compliance with the License.+// You may obtain a copy of the License at+//+// http://www.apache.org/licenses/LICENSE-2.0+//+// Unless required by applicable law or agreed to in writing, software+// distributed under the License is distributed on an "AS IS" BASIS,+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.+// See the License for the specific language governing permissions and+// limitations under the License.+//++package elasticsearch++import (+ "reflect"+ "testing"+)++func TestMessageSubstringEscapesWildcardCharacters(t *testing.T) {+ got := buildBoolQueryFromConditionRaw(map[string]interface{}{"session_id_contains": `a*b?c\d`}, nil, false, true)+ want := map[string]interface{}{"filter": []interface{}{map[string]interface{}{"wildcard": map[string]interface{}{"session_id": `*a\*b\?c\\d*`}}}}+ if !reflect.DeepEqual(got, map[string]interface{}{"bool": want}) {+ t.Fatalf("query = %#v, want %#v", got, want)+ }+}diff --git a/internal/engine/infinity/chunk.go b/internal/engine/infinity/chunk.goindex 5bf11a6ca9..619fc1fe39 100644--- a/internal/engine/infinity/chunk.go+++ b/internal/engine/infinity/chunk.go@@ -19,6 +19,7 @@ package infinityimport ("context""encoding/json"+ "errors""fmt""hash/fnv""maps"@@ -1085,6 +1086,7 @@ func (e *Engine) Search(ctx context.Context, req *types.SearchRequest) (*types.S}orderBy := req.OrderBy+ mergeMemoryOrder := isMemoryIndex && !hasTextMatch && !hasVectorMatch && orderBy != nil && len(orderBy.Fields) > 0var rankFeature map[string]float64if req.RankFeature != nil {rankFeature = req.RankFeature@@ -1198,8 +1200,11 @@ func (e *Engine) Search(ctx context.Context, req *types.SearchRequest) (*types.S}}tableOutputColumns := outputColumns+ if mergeMemoryOrder {+ tableOutputColumns = unionSortColumns(tableOutputColumns, orderBy)+ }if wildcardSelect {- tableOutputColumns = expandSelectWildcards(outputColumns, tableColumns)+ tableOutputColumns = expandSelectWildcards(tableOutputColumns, tableColumns)}tableFilterParts := append([]string(nil), filterParts...)if len(filterCopy) > 0 {@@ -1387,9 +1392,13 @@ func (e *Engine) Search(ctx context.Context, req *types.SearchRequest) (*types.S}// Set limit and offset- table = table.Limit(pageSize)- if offset > 0 {- table = table.Offset(offset)+ if mergeMemoryOrder {+ table = table.Limit(pageSize + offset)+ } else {+ table = table.Limit(pageSize)+ if offset > 0 {+ table = table.Offset(offset)+ }}// Request total_hits_count from Infinity@@ -1493,6 +1502,10 @@ func (e *Engine) Search(ctx context.Context, req *types.SearchRequest) (*types.SallResults = sortByScore(allResults, len(allResults))}+ if mergeMemoryOrder {+ sortChunksByFields(allResults, orderBy)+ allResults = allResults[min(offset, len(allResults)):]+ }if len(allResults) > pageSize {allResults = allResults[:pageSize]}@@ -1848,6 +1861,12 @@ func (e *Engine) GetChunk(ctx context.Context, tableName, chunkID string, datasefor _, tblName := range tableNames {table, err := db.GetTable(tblName)if err != nil {+ if isMemoryIndexName(tableName) {+ var infinityErr *infinity.InfinityException+ if !errors.As(err, &infinityErr) || infinity.ErrorCode(infinityErr.ErrorCode) != infinity.ErrorCodeTableNotExist {+ return nil, fmt.Errorf("failed to open message table: %w", err)+ }+ }continue}@@ -1855,11 +1874,17 @@ func (e *Engine) GetChunk(ctx context.Context, tableName, chunkID string, datasefilter := fmt.Sprintf("id = '%s'", chunkID)result, err := table.Output([]string{"*"}).Filter(filter).ToResult()if err != nil {+ if isMemoryIndexName(tableName) {+ return nil, fmt.Errorf("failed to read message: %w", err)+ }continue}qr, ok := result.(*infinity.QueryResult)if !ok {+ if isMemoryIndexName(tableName) {+ return nil, fmt.Errorf("unexpected message query result %T", result)+ }continue}@@ -2176,6 +2201,12 @@ func mapMemoryMessageStorageFields(row map[string]interface{}) {// to the logical fields the memory service reads.func normalizeMemoryMessageRows(rows []map[string]interface{}) {for _, row := range rows {+ for field, value := range row {+ if vectorColumnPattern.MatchString(field) {+ row["content_embed"] = value+ delete(row, field)+ }+ }if val, ok := row["message_type_kwd"]; ok {row["message_type"] = valdelete(row, "message_type_kwd")@@ -3134,6 +3165,13 @@ func equivalentConditionToStrRaw(condition map[string]interface{}, tableColumnscontinue}+ if memIndex && k == "session_id_contains" {+ if text, ok := v.(string); ok {+ pattern := strings.NewReplacer("'", `\x27`, `"`, `\x22`).Replace(regexp.QuoteMeta(text))+ cond = append(cond, infinity.RegexFilter("session_id", pattern))+ }+ continue+ }// Handle must_not speciallyif k == "must_not" {if m, ok := v.(map[string]interface{}); ok {diff --git a/internal/engine/infinity/message_contract_integration_test.go b/internal/engine/infinity/message_contract_integration_test.gonew file mode 100644index 0000000000..08ea52069e--- /dev/null+++ b/internal/engine/infinity/message_contract_integration_test.go@@ -0,0 +1,110 @@+//go:build integration++//+// Copyright 2026 The InfiniFlow Authors. All Rights Reserved.+//+// Licensed under the Apache License, Version 2.0 (the "License");+// you may not use this file except in compliance with the License.+// You may obtain a copy of the License at+//+// http://www.apache.org/licenses/LICENSE-2.0+//+// Unless required by applicable law or agreed to in writing, software+// distributed under the License is distributed on an "AS IS" BASIS,+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.+// See the License for the specific language governing permissions and+// limitations under the License.+//++package infinity++import (+ "fmt"+ "os"+ "strings"+ "testing"+ "time"++ "ragflow/internal/common"+ "ragflow/internal/engine/types"+ "ragflow/internal/server/config"++ sdk "github.com/infiniflow/infinity-go-sdk"+)++func TestMessageSubstringLiteralAndReadErrors(t *testing.T) {+ if err := common.InitLogger("error", common.FileOutput{}, "sdk_message_contract"); err != nil {+ t.Fatal(err)+ }+ uri := os.Getenv("RAGFLOW_INFINITY_URI")+ if uri == "" {+ uri = "localhost:23817"+ }+ e, err := NewEngine(t.Context(), config.InfinityConfig{URI: uri, DBName: "sdk_source_contract"})+ if err != nil {+ t.Fatal(err)+ }+ t.Cleanup(func() { _ = e.Close() })+ db, release, err := e.client.checkoutDatabase(t.Context(), "message_contract_test")+ if err != nil {+ t.Fatal(err)+ }+ defer release()+ base := fmt.Sprintf("memory_contract_%d", time.Now().UnixNano())+ name := base + "_test"+ table, err := db.CreateTable(name, sdk.TableSchema{&sdk.ColumnDefinition{Name: "id", DataType: "varchar"}, &sdk.ColumnDefinition{Name: "session_id", DataType: "varchar"}, &sdk.ColumnDefinition{Name: "valid_at", DataType: "varchar"}}, sdk.ConflictTypeError)+ if err != nil {+ t.Fatal(err)+ }+ t.Cleanup(func() { _, _ = db.DropTable(name, sdk.ConflictTypeIgnore) })+ for i, part := range []string{"middle", "a'b", `a"b`, `both'"quotes`, `slash\path`, "a_%b", "x OR 1=1"} {+ id := fmt.Sprint(i)+ if _, err := table.Insert([]map[string]interface{}{{"id": id, "session_id": "prefix" + part + "suffix", "valid_at": "2026-01-01"}}); err != nil {+ t.Fatal(err)+ }+ filter := equivalentConditionToStrRaw(map[string]interface{}{"session_id_contains": part}, nil, true)+ result, err := table.Output([]string{"id"}).Filter(filter).ToResult()+ if err != nil {+ t.Fatalf("%q: %v", part, err)+ }+ ids := result.(*sdk.QueryResult).Data["id"]+ if len(ids) != 1 || ids[0] != id {+ t.Fatalf("part=%q rows=%v filter=%s", part, ids, filter)+ }+ }++ laterName := base + "_later"+ later, err := db.CreateTable(laterName, sdk.TableSchema{&sdk.ColumnDefinition{Name: "id", DataType: "varchar"}, &sdk.ColumnDefinition{Name: "valid_at", DataType: "varchar"}}, sdk.ConflictTypeError)+ if err != nil {+ t.Fatal(err)+ }+ t.Cleanup(func() { _, _ = db.DropTable(laterName, sdk.ConflictTypeIgnore) })+ if _, err := later.Insert([]map[string]interface{}{{"id": "newest", "valid_at": "2026-02-01"}}); err != nil {+ t.Fatal(err)+ }+ for offset, expected := range []string{"newest", "2026-01-01"} {+ result, err := e.Search(t.Context(), &types.SearchRequest{IndexNames: []string{base}, KbIDs: []string{"test", "later"}, SelectFields: []string{"id", "q_*_vec"}, Limit: 1, Offset: offset, OrderBy: (&types.OrderByExpr{}).Desc("valid_at")})+ if err != nil {+ t.Fatal(err)+ }+ if len(result.Chunks) != 1 {+ t.Fatalf("offset=%d result=%+v", offset, result)+ }+ field := "id"+ if offset > 0 {+ field = "valid_at"+ }+ if result.Chunks[0][field] != expected {+ t.Fatalf("offset=%d rows=%v", offset, result.Chunks)+ }+ }+ if _, err := table.DropColumns([]string{"id"}); err != nil {+ t.Fatal(err)+ }+ if _, err := e.GetChunk(t.Context(), base, "missing", []string{"test"}); err == nil || !strings.Contains(err.Error(), "failed to read message") {+ t.Fatalf("query error masked: %v", err)+ }+ if value, err := e.GetChunk(t.Context(), base, "missing", []string{"absent"}); err != nil || value != nil {+ t.Fatalf("absent table=%v,%v", value, err)+ }+}diff --git a/internal/engine/infinity/message_contract_test.go b/internal/engine/infinity/message_contract_test.gonew file mode 100644index 0000000000..15680fcd6e--- /dev/null+++ b/internal/engine/infinity/message_contract_test.go@@ -0,0 +1,43 @@+//+// Copyright 2026 The InfiniFlow Authors. All Rights Reserved.+//+// Licensed under the Apache License, Version 2.0 (the "License");+// you may not use this file except in compliance with the License.+// You may obtain a copy of the License at+//+// http://www.apache.org/licenses/LICENSE-2.0+//+// Unless required by applicable law or agreed to in writing, software+// distributed under the License is distributed on an "AS IS" BASIS,+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.+// See the License for the specific language governing permissions and+// limitations under the License.+//++package infinity++import (+ "strings"+ "testing"+)++func TestMessageSubstringFilterKeepsExactFilters(t *testing.T) {+ got := equivalentConditionToStrRaw(map[string]interface{}{"session_id_contains": "part_%'x", "agent_id": "exact"}, nil, true)+ if !strings.Contains(got, "regex(session_id") || !strings.Contains(got, `part_%\x27x`) || !strings.Contains(got, "agent_id='exact'") {+ t.Fatal(got)+ }+ exact := buildFilterFromConditionRaw(map[string]interface{}{"session_id": "part"}, nil)+ if strings.Contains(exact, "LIKE") {+ t.Fatal(exact)+ }+}+func TestMemoryEmbeddingPublicField(t *testing.T) {+ row := map[string]interface{}{"q_3_vec": []float32{1, 2, 3}, "message_type_kwd": "raw"}+ normalizeMemoryMessageRows([]map[string]interface{}{row})+ if _, ok := row["q_3_vec"]; ok {+ t.Fatal(row)+ }+ if row["content_embed"] == nil || row["message_type"] != "raw" {+ t.Fatal(row)+ }+}diff --git a/internal/engine/oceanbase/filter.go b/internal/engine/oceanbase/filter.goindex 0c5f3225f3..e006510f8f 100644--- a/internal/engine/oceanbase/filter.go+++ b/internal/engine/oceanbase/filter.go@@ -40,6 +40,11 @@ func buildFilter(condition map[string]interface{}, kind string) (string, []interif isEmptyFilterValue(value) {continue}+ if kind == "memory" && key == "session_id_contains" {+ parts = append(parts, "INSTR(`session_id`, ?) > 0")+ args = append(args, value)+ continue+ }switch key {case "exists":column, ok := value.(string)diff --git a/internal/engine/oceanbase/message_contract_test.go b/internal/engine/oceanbase/message_contract_test.gonew file mode 100644index 0000000000..11326cbbe9--- /dev/null+++ b/internal/engine/oceanbase/message_contract_test.go@@ -0,0 +1,53 @@+//+// Copyright 2026 The InfiniFlow Authors. All Rights Reserved.+//+// Licensed under the Apache License, Version 2.0 (the "License");+// you may not use this file except in compliance with the License.+// You may obtain a copy of the License at+//+// http://www.apache.org/licenses/LICENSE-2.0+//+// Unless required by applicable law or agreed to in writing, software+// distributed under the License is distributed on an "AS IS" BASIS,+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.+// See the License for the specific language governing permissions and+// limitations under the License.+//++package oceanbase++import (+ "reflect"+ "strings"+ "testing"+)++func TestMessageSubstringFilterKeepsExactFilters(t *testing.T) {+ got, args, err := buildFilter(map[string]interface{}{"session_id_contains": "part_%'x"}, "memory")+ if err != nil || got != "INSTR(`session_id`, ?) > 0" || !reflect.DeepEqual(args, []interface{}{"part_%'x"}) {+ t.Fatalf("%s %v %v", got, args, err)+ }+ exact, _, err := buildFilter(map[string]interface{}{"session_id": "part"}, "memory")+ if err != nil || !strings.Contains(exact, " = ?") {+ t.Fatal(exact, err)+ }+}++func TestMemoryMessageIDsDecodeAsIntegers(t *testing.T) {+ for _, tc := range []struct {+ stored string+ want int64+ }{{"42", 42}, {"9223372036854775807", 9223372036854775807}} {+ row := decodeLogicalRow(map[string]interface{}{"message_id": tc.stored}, "memory")+ if row["message_id"] != tc.want {+ t.Fatalf("message_id = %#v, want %d", row["message_id"], tc.want)+ }+ }+}++func TestMemoryContentIncludesUnsetForgetTime(t *testing.T) {+ row := decodeLogicalRow(map[string]interface{}{"message_id": "42", "content_ltks": "content"}, "memory")+ if value, ok := row["forget_at"]; !ok || value != nil {+ t.Fatalf("unset forget_at = %#v, present=%v", value, ok)+ }+}diff --git a/internal/engine/oceanbase/rows.go b/internal/engine/oceanbase/rows.goindex 1908e8b909..aa6f61757e 100644--- a/internal/engine/oceanbase/rows.go+++ b/internal/engine/oceanbase/rows.go@@ -21,6 +21,7 @@ import ("database/sql""encoding/json""fmt"+ "strconv""strings")@@ -62,6 +63,9 @@ func (e *Engine) queryRows(ctx context.Context, query string, args ...interface{func decodeLogicalRow(row map[string]interface{}, kind string) map[string]interface{} {result := make(map[string]interface{}, len(row))+ if kind == "memory" {+ result["forget_at"] = nil+ }for rawColumn, value := range row {column := rawColumnif kind == "memory" {@@ -74,6 +78,13 @@ func decodeLogicalRow(row map[string]interface{}, kind string) map[string]interfif kind == "chunk" && column == "_order_id" {column = "chunk_order_int"}+ if kind == "memory" && column == "message_id" {+ if text, ok := value.(string); ok {+ if id, err := strconv.ParseInt(text, 10, 64); err == nil {+ value = id+ }+ }+ }if kind == "memory" && column == "status" {switch status := value.(type) {case int64:diff --git a/internal/engine/oceanbase/schema.go b/internal/engine/oceanbase/schema.goindex 59e4536368..df9dbeba8f 100644--- a/internal/engine/oceanbase/schema.go+++ b/internal/engine/oceanbase/schema.go@@ -231,8 +231,12 @@ func (e *Engine) ensureTableWithLock(ctx context.Context, tableName string, colufor _, column := range columns {definitions = append(definitions, quoteIdentifier(column.name)+" "+column.typeSQL)}- query := fmt.Sprintf("CREATE TABLE %s (%s) DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci ORGANIZATION=heap",- quoteIdentifier(tableName), strings.Join(definitions, ", "))+ collation := "utf8mb4_unicode_ci"+ if e.engineType == "seekdb" {+ collation = "utf8mb4_general_ci"+ }+ query := fmt.Sprintf("CREATE TABLE %s (%s) DEFAULT CHARSET=utf8mb4 COLLATE=%s ORGANIZATION=heap",+ quoteIdentifier(tableName), strings.Join(definitions, ", "), collation)_, err := e.db.ExecContext(ctx, query)return err})diff --git a/internal/engine/oceanbase/schema_test.go b/internal/engine/oceanbase/schema_test.goindex 611247a770..673591461e 100644--- a/internal/engine/oceanbase/schema_test.go+++ b/internal/engine/oceanbase/schema_test.go@@ -159,3 +159,26 @@ func TestFindVectorColumnUsesExpectedColumn(t *testing.T) {t.Fatal(err)}}++func TestTableCollationMatchesEngine(t *testing.T) {+ for _, tc := range []struct{ engine, collation string }{{"oceanbase", "utf8mb4_unicode_ci"}, {"seekdb", "utf8mb4_general_ci"}} {+ t.Run(tc.engine, func(t *testing.T) {+ db, mock, err := sqlmock.New()+ if err != nil {+ t.Fatal(err)+ }+ defer db.Close()+ engine := newEngineWithDB(tc.engine, "test", db)+ query := regexp.QuoteMeta("SELECT COUNT(*) FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_SCHEMA = ? AND TABLE_NAME = ?")+ mock.ExpectQuery(query).WithArgs("test", "memory_test").WillReturnRows(sqlmock.NewRows([]string{"COUNT(*)"}).AddRow(0))+ mock.ExpectExec(regexp.QuoteMeta("CREATE TABLE `memory_test` (`id` VARCHAR(32)) DEFAULT CHARSET=utf8mb4 COLLATE=" + tc.collation + " ORGANIZATION=heap")).WillReturnResult(sqlmock.NewResult(0, 0))+ mock.ExpectQuery(query).WithArgs("test", "memory_test").WillReturnRows(sqlmock.NewRows([]string{"COUNT(*)"}).AddRow(1))+ if err := engine.ensureTable(t.Context(), "memory_test", []columnDefinition{{name: "id", typeSQL: "VARCHAR(32)"}}, "test_"); err != nil {+ t.Fatal(err)+ }+ if err := mock.ExpectationsWereMet(); err != nil {+ t.Fatal(err)+ }+ })+ }+}diff --git a/internal/handler/memory.go b/internal/handler/memory.goindex 5faf2a7d8a..2075c25f74 100644--- a/internal/handler/memory.go+++ b/internal/handler/memory.go@@ -22,6 +22,7 @@ package handlerimport ("encoding/json""errors"+ "math""net/http""strconv""strings"@@ -830,8 +831,16 @@ func (h *MemoryHandler) SearchMessage(c *gin.Context) {query := c.Query("query")- similarityThreshold, _ := strconv.ParseFloat(c.DefaultQuery("similarity_threshold", "0.2"), 64)- keywordsSimilarityWeight, _ := strconv.ParseFloat(c.DefaultQuery("keywords_similarity_weight", "0.7"), 64)+ similarityThreshold, err := strconv.ParseFloat(c.DefaultQuery("similarity_threshold", "0.2"), 64)+ if err != nil || math.IsNaN(similarityThreshold) || math.IsInf(similarityThreshold, 0) || similarityThreshold < 0 || similarityThreshold > 1 {+ common.ErrorWithCode(c, common.CodeArgumentError, "similarity_threshold must be a finite number between 0 and 1")+ return+ }+ keywordsSimilarityWeight, err := strconv.ParseFloat(c.DefaultQuery("keywords_similarity_weight", "0.7"), 64)+ if err != nil || math.IsNaN(keywordsSimilarityWeight) || math.IsInf(keywordsSimilarityWeight, 0) || keywordsSimilarityWeight < 0 || keywordsSimilarityWeight > 1 {+ common.ErrorWithCode(c, common.CodeArgumentError, "keywords_similarity_weight must be a finite number between 0 and 1")+ return+ }topN, _ := strconv.Atoi(c.DefaultQuery("top_n", "5"))if topN <= 0 || topN > 100 {common.ResponseWithCodeData(c, common.CodeArgumentError, nil, "top_n must be between 1 and 100")diff --git a/internal/handler/memory_message_test.go b/internal/handler/memory_message_test.goindex 9f4f4b6388..9e295009e1 100644--- a/internal/handler/memory_message_test.go+++ b/internal/handler/memory_message_test.go@@ -91,3 +91,24 @@ func TestForgetMessageRejectsMalformedPath(t *testing.T) {t.Fatalf("code = %v, want %v; body=%s", code, common.CodeArgumentError, w.Body.String())}}++func TestSearchMessageRejectsInvalidSimilarity(t *testing.T) {+ for _, field := range []string{"similarity_threshold", "keywords_similarity_weight"} {+ for _, value := range []string{"-0.1", "1.1", "invalid", "nan", "inf"} {+ t.Run(field+value, func(t *testing.T) {+ w := httptest.NewRecorder()+ c, _ := gin.CreateTestContext(w)+ c.Set("user", &entity.User{ID: "user-1"})+ c.Request = httptest.NewRequest("GET", "/messages/search?"+field+"="+value, nil)+ (&MemoryHandler{}).SearchMessage(c)+ var payload struct{ Code int }+ if err := json.Unmarshal(w.Body.Bytes(), &payload); err != nil {+ t.Fatal(err)+ }+ if payload.Code != 101 {+ t.Fatalf("response=%s", w.Body.String())+ }+ })+ }+ }+}diff --git a/internal/service/memory.go b/internal/service/memory.goindex e7f8c5e33a..30a6e0ade5 100644--- a/internal/service/memory.go+++ b/internal/service/memory.go@@ -21,6 +21,7 @@ import ("context""errors""fmt"+ "math""ragflow/internal/common""ragflow/internal/entity""ragflow/internal/entity/models"@@ -1151,6 +1152,16 @@ func (s *MemoryService) UpdateMessageStatus(ctx context.Context, userID, memoryI}messageDocID := fmt.Sprintf("%s_%d", memoryID, messageID)+ message, err := s.docEngine.GetChunk(ctx, MemoryIndexName(memory.TenantID), messageDocID, []string{memoryID})+ if err != nil {+ if isMessageDocumentNotFound(err) {+ return false, &ResourceNotFoundError{Resource: "Message", ID: messageDocID}+ }+ return false, fmt.Errorf("failed to load message before status update: %w", err)+ }+ if message == nil {+ return false, &ResourceNotFoundError{Resource: "Message", ID: messageDocID}+ }statusValue := 0if status {statusValue = 1@@ -1206,6 +1217,14 @@ func (s *MemoryService) GetMessageContent(ctx context.Context, userID, memoryID}func (s *MemoryService) SearchMessage(ctx context.Context, userID string, filterDict, params map[string]interface{}) ([]map[string]interface{}, common.ErrorCode, error) {+ for _, field := range []string{"similarity_threshold", "keywords_similarity_weight"} {+ if value, exists := params[field]; exists {+ number := memoryFloatParam(value, math.NaN())+ if math.IsNaN(number) || math.IsInf(number, 0) || number < 0 || number > 1 {+ return nil, common.CodeArgumentError, fmt.Errorf("%s must be a finite number between 0 and 1", field)+ }+ }+ }memoryIDs := splitFilterValues(filterDict["memory_id"])memories, err := s.filterAccessibleMemories(ctx, userID, memoryIDs)if err != nil {@@ -1869,7 +1888,7 @@ func (s *MemoryService) listMemoryMessages(ctx context.Context, memory *entity.Mfilter["agent_id"] = agentIDs}if keywords = strings.TrimSpace(keywords); keywords != "" {- filter["session_id"] = keywords+ filter["session_id_contains"] = keywords}filter["memory_id"] = []string{memoryID}indexNames := memorySearchIndexNames([]*entity.Memory{memory}, s.docEngine)@@ -1881,7 +1900,7 @@ func (s *MemoryService) listMemoryMessages(ctx context.Context, memory *entity.MSelectFields: selectFields,Filter: filter,MatchExprs: []interface{}{},- OrderBy: (&enginetypes.OrderByExpr{}).Desc("valid_at"),+ OrderBy: (&enginetypes.OrderByExpr{}).Desc("valid_at").Desc("message_id"),}rawResult, err := s.docEngine.Search(ctx, rawReq)if err != nil {diff --git a/internal/service/memory_message_test.go b/internal/service/memory_message_test.goindex 979c06a3f2..277e03d124 100644--- a/internal/service/memory_message_test.go+++ b/internal/service/memory_message_test.go@@ -137,6 +137,9 @@ type memoryMessageDocEngine struct {updateID string}+func (e *memoryMessageDocEngine) GetChunk(context.Context, string, string, []string) (interface{}, error) {+ return map[string]interface{}{"id": "present"}, nil+}func (e *memoryMessageDocEngine) Search(ctx context.Context, req *enginetypes.SearchRequest) (*enginetypes.SearchResult, error) {e.searchReq = reqif e.searchResp != nil {@@ -1042,3 +1045,43 @@ func TestUpdateMessageUpdatesStatusByMessageDocID(t *testing.T) {t.Fatalf("status update = %+v, want status 1", docEngine.updateValue)}}++type missingMessageEngine struct {+ memoryMessageDocEngine+ getErr error+}++func (e *missingMessageEngine) GetChunk(context.Context, string, string, []string) (interface{}, error) {+ return nil, e.getErr+}+func TestUpdateMessageRejectsMissingAndFailedReads(t *testing.T) {+ for _, readErr := range []error{nil, enginetypes.ErrDocumentNotFound, errors.New("database unavailable")} {+ setupMemoryMessageTestDB(t)+ seedMemoryMessages(t)+ e := &missingMessageEngine{getErr: readErr}+ svc := &MemoryService{memoryDAO: dao.NewMemoryDAO(), db: dao.DB, docEngine: e}+ ok, err := svc.UpdateMessage(serviceTestContext(t, "user-1", "user-1"), "user-1", "mem-owned", 42, true)+ if ok || err == nil || e.updateCond != nil {+ t.Fatalf("ok=%v error=%v update=%v", ok, err, e.updateCond)+ }+ var missing *ResourceNotFoundError+ if readErr != nil && !errors.Is(readErr, enginetypes.ErrDocumentNotFound) {+ if !errors.Is(err, readErr) {+ t.Fatal(err)+ }+ } else if !errors.As(err, &missing) {+ t.Fatalf("expected missing, got%v", err)+ }+ }+}++func TestMemorySearchRejectsInvalidSimilarityBeforeStorage(t *testing.T) {+ for _, field := range []string{"similarity_threshold", "keywords_similarity_weight"} {+ for _, value := range []interface{}{-0.1, 1.1, "invalid", math.NaN(), math.Inf(1), nil} {+ _, code, err := (&MemoryService{}).SearchMessage(t.Context(), "user", nil, map[string]interface{}{field: value})+ if code != common.CodeArgumentError || err == nil {+ t.Fatalf("%s=%v code=%v err=%v", field, value, code, err)+ }+ }+ }+}diff --git a/test/testcases/test_sdk_api/test_message_management/test_get_message_content.py b/test/testcases/test_sdk_api/test_message_management/test_get_message_content.pyindex 8a9b00af6b..b075f95739 100644--- a/test/testcases/test_sdk_api/test_message_management/test_get_message_content.py+++ b/test/testcases/test_sdk_api/test_message_management/test_get_message_content.py@@ -43,8 +43,6 @@ class TestGetMessageContent:assert content["status"] is True, contentdef test_get_message_content_embedding(self, populated_memory, doc_engine):- if doc_engine == "infinity":- pytest.skip("Go Infinity GetChunk returns q_<dimension>_vec without mapping it to documented content_embed (internal/engine/infinity/chunk.go:1907-1911,2177).")memory = populated_memory["memory"]content = memory.get_message_content(populated_memory["rows"][0]["message_id"])vector = content["content_embed"]diff --git a/test/testcases/test_sdk_api/test_message_management/test_list_message.py b/test/testcases/test_sdk_api/test_message_management/test_list_message.pyindex 99f11b2d48..27de3f4fc6 100644--- a/test/testcases/test_sdk_api/test_message_management/test_list_message.py+++ b/test/testcases/test_sdk_api/test_message_management/test_list_message.py@@ -92,8 +92,6 @@ class TestMessageList:_assert_messages(result, populated_memory, expected)def test_search_keyword_substring(self, populated_memory, doc_engine):- if doc_engine in {"infinity", "oceanbase", "seekdb"}:- pytest.skip("Go Infinity/OceanBase session_id filters use equality, contrary to Python SDK docs' fuzzy session-ID contract (infinity/chunk.go, oceanbase/filter.go)")expected = populated_memory["rows"][2:3]keyword = expected[0]["session_id"][4:]assert keyword != expected[0]["session_id"]diff --git a/test/testcases/test_sdk_api/test_message_management/test_search_message.py b/test/testcases/test_sdk_api/test_message_management/test_search_message.pyindex da6bed53b4..e4fe0d47d1 100644--- a/test/testcases/test_sdk_api/test_message_management/test_search_message.py+++ b/test/testcases/test_sdk_api/test_message_management/test_search_message.py@@ -137,9 +137,6 @@ class TestSearchMessage:)assert_matches(messages, populated_memory, range(5))- @pytest.mark.skip(- reason="Go MemoryHandler.SearchMessage parses float parameters without checking errors or documented [0,1] ranges (internal/handler/memory.go); invalid values reach search instead of returning argument errors"- )@pytest.mark.parametrize("field", ["similarity_threshold", "keywords_similarity_weight"])@pytest.mark.parametrize("value", [-0.1, 1.1, "invalid", "nan", "inf"])def test_invalid_similarity_parameters(self, client, populated_memory, field, value):diff --git a/test/testcases/test_sdk_api/test_message_management/test_update_message_status.py b/test/testcases/test_sdk_api/test_message_management/test_update_message_status.pyindex f0ff5b8b2d..66fb58c652 100644--- a/test/testcases/test_sdk_api/test_message_management/test_update_message_status.py+++ b/test/testcases/test_sdk_api/test_message_management/test_update_message_status.py@@ -82,10 +82,6 @@ class TestUpdateMessageStatus:populated_memory["memory"].update_message_status(message_id, False)def test_nonexistent_message(self, populated_memory, doc_engine):- if doc_engine == "infinity":- pytest.skip("Infinity UpdateChunks discards the update result and succeeds for a missing message (internal/engine/infinity/chunk.go:743-758); status update must report missing Message.")- if doc_engine in ("oceanbase", "seekdb"):- pytest.skip("OceanBase UpdateChunks ignores SQL affected rows and succeeds for a missing message (internal/engine/oceanbase/crud.go:292-294); status update must report missing Message.")with pytest.raises(Exception, match="Message .*not found"):populated_memory["memory"].update_message_status(9223372036854775807, False)