Self-evolving Context Database for AI Agents. Unify Agent Memory, Knowledge RAG and Skills.
Python agent-contextagent-memoryagent-pluginsagentic-ragcontext-databasedsh-pluginknowledge-basememorymemory-managementself-evolvingvector-database
Feat/memory isolation (#1905)
chenjw99ae8fea710e
diff --git a/openviking/prompts/templates/memory/events.yaml b/openviking/prompts/templates/memory/events.yamlindex 8b23469f1..e1a6d66a1 100644--- a/openviking/prompts/templates/memory/events.yaml+++ b/openviking/prompts/templates/memory/events.yaml@@ -32,14 +32,15 @@ fields:- name: event_nametype: stringdescription: |- Output a real-world event name only.+ Output a concrete noun phrase representing a real-world activity or occurrence.Rules:1. Can be Chinese or English;2. If English: all lowercase, use underscore instead of space, maximum 3 words;3. Never include any date, time, year or number;- 4. Must be the actual real-life event being discussed, NOT the chat/conversation itself;- 5. Forbidden format: person name + chat, chat about xxx, daily talk;- 6. Output only the event name, no extra explanation.+ 4. Must name the real-world activity/occurrence, NOT the conversation about it;+ 5. Names ending with _chat, _talk, _conversation, _catchup, _discussion are forbidden;+ 6. Patterns like "person_chat", "chat_about_xxx", "daily_talk" are forbidden;+ 7. Output only the event name, no extra explanation.merge_op: immutable- name: goaldiff --git a/openviking/server/identity.py b/openviking/server/identity.pyindex 90b0607d7..f1179b505 100644--- a/openviking/server/identity.py+++ b/openviking/server/identity.py@@ -98,6 +98,7 @@ class RequestContext:class ToolContext:"""Tool-level context, containing request context and additional tool-specific information."""+viking_fs: VikingFSrequest_ctx: RequestContextdefault_search_uris: List[str] = field(default_factory=list)diff --git a/openviking/session/compressor_v2.py b/openviking/session/compressor_v2.pyindex 6735c3b1f..00ce66c1e 100644--- a/openviking/session/compressor_v2.py+++ b/openviking/session/compressor_v2.py@@ -359,7 +359,11 @@ class SessionCompressorV2:deletes = []# Build lookup maps for efficient access- upsert_by_uri = {op.uris[0]: op for op in operations.upsert_operations if op.uris}+ # Handle multi-URI operations correctly+ upsert_by_uri = {}+ for op in operations.upsert_operations:+ for uri in op.uris:+ upsert_by_uri[uri] = opdelete_by_uri = {dc.uri: dc for dc in operations.delete_file_contents}# Process written_uris - distinguish between add and updatediff --git a/openviking/session/memory/__init__.py b/openviking/session/memory/__init__.pyindex c8c19998a..61f004177 100644--- a/openviking/session/memory/__init__.py+++ b/openviking/session/memory/__init__.py@@ -70,6 +70,8 @@ __all__ = ["MemoryLsTool","register_tool","get_tool",+ "get_tool_schemas",+ "list_tools","add_tool_call_pair_to_messages",# Language utilities and helpers"detect_language_from_conversation",diff --git a/openviking/session/memory/extract_loop.py b/openviking/session/memory/extract_loop.pyindex b0dbbb071..ab47d8d5f 100644--- a/openviking/session/memory/extract_loop.py+++ b/openviking/session/memory/extract_loop.py@@ -325,7 +325,7 @@ The final output of the model must strictly follow the JSON Schema format shownfor op in upsert_operations:for uri in op.uris:old_content = self.context_provider.read_file_contents.get(uri)- if old_content:+ if old_content and op.old_memory_file_content is None:op.old_memory_file_content = old_contentbreakdiff --git a/openviking/session/memory/memory_updater.py b/openviking/session/memory/memory_updater.pyindex 5c7f10767..c6dafd982 100644--- a/openviking/session/memory/memory_updater.py+++ b/openviking/session/memory/memory_updater.py@@ -355,33 +355,50 @@ class MemoryUpdater:viking_fs = self._get_viking_fs()memory_type = resolved_op.memory_typeschema = self._registry.get(memory_type)- metadata: Dict[str, Any] = dict(resolved_op.memory_fields)- # Process fields defined in schema (apply merge_op)- for field in schema.fields:- if field.name in resolved_op.memory_fields:- patch_value = resolved_op.memory_fields[field.name]- # Get current value- if resolved_op.old_memory_file_content is None:- current_value = None- else:- if field.name == "content":- current_value = resolved_op.old_memory_file_content.plain_content- else:- current_value = resolved_op.old_memory_file_content.memory_fields.get(- field.name- )- # Use merge_op to process field value- merge_op = MergeOpFactory.from_field(field)- new_value = merge_op.apply(current_value, patch_value)- metadata[field.name] = new_value-- # serialize_with_metadata modifies metadata dict, so pass a copy- new_full_content = serialize_with_metadata(- metadata.copy(),- content_template=schema.content_template,- extract_context=extract_context,- )+ # Process each URI independentlyfor uri in resolved_op.uris:+ old_content = resolved_op.old_memory_file_content+ if old_content is None:+ # If no pre-fetched content, try to read it now+ try:+ content = await viking_fs.read_file(uri, ctx=ctx)+ if content:+ parsed = parse_memory_file_with_fields(content)+ old_content = MemoryFileContent(+ uri=uri,+ plain_content=parsed.get("content", ""),+ memory_fields=parsed+ )+ except Exception:+ # File doesn't exist yet, that's okay+ pass++ metadata: Dict[str, Any] = dict(resolved_op.memory_fields)+ # Process fields defined in schema (apply merge_op)+ for field in schema.fields:+ if field.name in resolved_op.memory_fields:+ patch_value = resolved_op.memory_fields[field.name]+ # Get current value for this URI+ if old_content is None:+ current_value = None+ else:+ if field.name == "content":+ current_value = old_content.plain_content+ else:+ current_value = old_content.memory_fields.get(+ field.name+ )+ # Use merge_op to process field value+ merge_op = MergeOpFactory.from_field(field)+ new_value = merge_op.apply(current_value, patch_value)+ metadata[field.name] = new_value++ # serialize_with_metadata modifies metadata dict, so pass a copy+ new_full_content = serialize_with_metadata(+ metadata.copy(),+ content_template=schema.content_template,+ extract_context=extract_context,+ )await viking_fs.write_file(uri, new_full_content, ctx=ctx)async def _apply_delete(self, uri: str, ctx: RequestContext) -> None:diff --git a/openviking/session/memory/merge_op/patch_handler.py b/openviking/session/memory/merge_op/patch_handler.pyindex 385c197f9..4f4155e78 100644--- a/openviking/session/memory/merge_op/patch_handler.py+++ b/openviking/session/memory/merge_op/patch_handler.py@@ -107,6 +107,8 @@ def fuzzy_search("""Perform a "middle-out" search to find the slice most similar to search_chunk.+ For single-line search, also checks for substring matches within each line.+Returns dict with bestScore, bestMatchIndex, bestMatchContent"""best_score = 0.0@@ -119,23 +121,63 @@ def fuzzy_search(left_index = mid_pointright_index = mid_point + 1+ # For single-line search, enable substring matching mode+ is_single_line = search_len == 1+ search_str = search_lines[0] if is_single_line else ""+while left_index >= start_index or right_index <= end_index - search_len:if left_index >= start_index:- original_chunk = "\n".join(lines[left_index : left_index + search_len])- similarity = get_similarity(original_chunk, search_chunk)- if similarity > best_score:- best_score = similarity- best_match_index = left_index- best_match_content = original_chunk+ if is_single_line:+ # Check substring match in this single line+ line = lines[left_index]+ # First check for exact substring match+ if search_str in line:+ best_score = 1.0+ best_match_index = left_index+ best_match_content = line+ left_index -= 1+ continue+ # If no exact match, try the best similarity with substrings+ line_score, line_content = _find_best_substring_match(line, search_str)+ if line_score > best_score:+ best_score = line_score+ best_match_index = left_index+ best_match_content = line_content+ else:+ # Original multi-line logic+ original_chunk = "\n".join(lines[left_index : left_index + search_len])+ similarity = get_similarity(original_chunk, search_chunk)+ if similarity > best_score:+ best_score = similarity+ best_match_index = left_index+ best_match_content = original_chunkleft_index -= 1if right_index <= end_index - search_len:- original_chunk = "\n".join(lines[right_index : right_index + search_len])- similarity = get_similarity(original_chunk, search_chunk)- if similarity > best_score:- best_score = similarity- best_match_index = right_index- best_match_content = original_chunk+ if is_single_line:+ # Check substring match in this single line+ line = lines[right_index]+ # First check for exact substring match+ if search_str in line:+ best_score = 1.0+ best_match_index = right_index+ best_match_content = line+ right_index += 1+ continue+ # If no exact match, try the best similarity with substrings+ line_score, line_content = _find_best_substring_match(line, search_str)+ if line_score > best_score:+ best_score = line_score+ best_match_index = right_index+ best_match_content = line_content+ else:+ # Original multi-line logic+ original_chunk = "\n".join(lines[right_index : right_index + search_len])+ similarity = get_similarity(original_chunk, search_chunk)+ if similarity > best_score:+ best_score = similarity+ best_match_index = right_index+ best_match_content = original_chunkright_index += 1return {@@ -145,6 +187,40 @@ def fuzzy_search(}+def _find_best_substring_match(line: str, search_str: str) -> tuple[float, str]:+ """Find the best matching substring in a line."""+ best_score = 0.0+ best_content = ""+ search_len = len(search_str)+ line_len = len(line)++ # If search string is longer than line, just compare the whole line+ if search_len >= line_len:+ return get_similarity(line, search_str), line++ # Try sliding window for best match (limit to reasonable checks for performance)+ # First check at start, end, and a few positions in between+ positions_to_check = [0, line_len - search_len]+ if line_len > search_len * 3:+ positions_to_check.append(line_len // 2 - search_len // 2)++ for i in positions_to_check:+ if 0 <= i <= line_len - search_len:+ substring = line[i:i+search_len]+ score = get_similarity(substring, search_str)+ if score > best_score:+ best_score = score+ best_content = substring++ # Also compare with the whole line as fallback+ whole_line_score = get_similarity(line, search_str)+ if whole_line_score > best_score:+ best_score = whole_line_score+ best_content = line++ return best_score, best_content++# ============================================================================# Line Number Utilities (from RooCode)# ============================================================================@@ -426,21 +502,57 @@ class MultiSearchReplaceDiffStrategy:if not matches:return DiffResult(success=True, content=original_content)+ # First try simple substring replacement - this handles the common case+ result_content = original_content+ all_applied = True+ processed_matches = []++ for match in matches:+ search_content = unescape_markers(match.get("searchContent", ""))+ replace_content = unescape_markers(match.get("replaceContent", ""))++ if search_content == replace_content:+ continue++ has_line_numbers = (+ every_line_has_line_numbers(search_content)+ and every_line_has_line_numbers(replace_content)+ ) or (every_line_has_line_numbers(search_content) and replace_content.strip() == "")++ if has_line_numbers:+ search_content = strip_line_numbers(search_content)+ replace_content = strip_line_numbers(replace_content)++ if not search_content:+ all_applied = False+ break++ if search_content not in result_content:+ all_applied = False+ break++ processed_matches.append((search_content, replace_content))++ if all_applied and processed_matches:+ for search_content, replace_content in processed_matches:+ result_content = result_content.replace(search_content, replace_content)+ return DiffResult(success=True, content=result_content)++ # Fall back to line-based approach for complex cases# Detect line ending from original contentline_ending = "\r\n" if "\r\n" in original_content else "\n"result_lines = re.split(r"\r?\n", original_content)- delta = 0diff_results = []applied_count = 0- # Sort replacements by start_line+ # Sort replacements by startLinereplacements = [{- "startLine": int(match.get("startLine", 0)),- "searchContent": match.get("searchContent", ""),- "replaceContent": match.get("replaceContent", ""),+ "startLine": int(m.get("startLine", 0)),+ "searchContent": m.get("searchContent", ""),+ "replaceContent": m.get("replaceContent", ""),}- for match in matches+ for m in matches]replacements.sort(key=lambda x: x["startLine"])@@ -675,7 +787,6 @@ class MultiSearchReplaceDiffStrategy:before_match = result_lines[:match_index]after_match = result_lines[match_index + len(search_lines) :]result_lines = before_match + indented_replace_lines + after_match- delta = delta - len(matched_lines) + len(replace_lines)applied_count += 1final_content = line_ending.join(result_lines)@@ -856,7 +967,31 @@ def apply_str_patch(original_content: str, patch: StrPatch) -> str:if not patch.blocks:return original_content- # Directly convert StrPatch to internal format, skip string conversion+ # First try simple substring replacement - this handles the common case+ result_content = original_content+ all_applied = True++ for block in patch.blocks:+ search_content = unescape_markers(block.search)+ replace_content = unescape_markers(block.replace)++ if search_content == replace_content:+ continue++ if not search_content:+ all_applied = False+ break++ if search_content not in result_content:+ all_applied = False+ break++ result_content = result_content.replace(search_content, replace_content)++ if all_applied:+ return result_content++ # Fall back to line-based approach for complex casesstrategy = MultiSearchReplaceDiffStrategy(fuzzy_threshold=0.8)# Convert StrPatch blocks to internal match format@@ -874,7 +1009,6 @@ def apply_str_patch(original_content: str, patch: StrPatch) -> str:if not matches:return original_content- # Apply using the same logic as apply_diff, but with pre-parsed matches# Detect line ending from original contentline_ending = "\r\n" if "\r\n" in original_content else "\n"result_lines = re.split(r"\r?\n", original_content)@@ -884,11 +1018,11 @@ def apply_str_patch(original_content: str, patch: StrPatch) -> str:# Sort replacements by start_linereplacements = [{- "startLine": int(match.get("startLine", 0)),- "searchContent": match.get("searchContent", ""),- "replaceContent": match.get("replaceContent", ""),+ "startLine": int(m.get("startLine", 0)),+ "searchContent": m.get("searchContent", ""),+ "replaceContent": m.get("replaceContent", ""),}- for match in matches+ for m in matches]replacements.sort(key=lambda x: x["startLine"])@@ -1095,7 +1229,9 @@ def apply_str_patch(original_content: str, patch: StrPatch) -> str:# Get indent from current replace linecurrent_replace_match = re.match(r"^[\t ]*", line)- current_replace_indent = current_replace_match.group(0) if current_replace_match else ""+ current_replace_indent = (+ current_replace_match.group(0) if current_replace_match else ""+ )# Calculate relative indent level (how much deeper/shallower this line is compared to search)relative_level = len(current_replace_indent) - len(search_indent)diff --git a/openviking/session/memory/schema_model_generator.py b/openviking/session/memory/schema_model_generator.pyindex c0e1b370c..7a2162371 100644--- a/openviking/session/memory/schema_model_generator.py+++ b/openviking/session/memory/schema_model_generator.py@@ -224,7 +224,8 @@ class SchemaModelGenerator:field_definitions[mt.memory_type] = (List[flat_model], # type: ignoreField(- default_factory=list, description=f"{mt.memory_type} memories (top-level field, do not nest inside other arrays)"+ default_factory=list,+ description=f"{mt.memory_type} memories: {mt.description} (top-level field, do not nest inside other arrays)"),)diff --git a/openviking/session/memory/tools.py b/openviking/session/memory/tools.pyindex 6624e494f..24c595465 100644--- a/openviking/session/memory/tools.py+++ b/openviking/session/memory/tools.py@@ -119,7 +119,7 @@ class MemoryTool(ABC):Execute the tool with given parameters.Args:- ctx: Tool context+ ctx: Tool context (contains viking_fs)**kwargs: Tool-specific parametersReturns:@@ -332,6 +332,11 @@ def get_tool(name: str) -> Optional[MemoryTool]:LLM_TOOLS = ["read"]+def get_tool_schemas() -> List[Dict[str, Any]]:+ """Get tools exposed to LLM in OpenAI function schema format."""+ return [tool.to_schema() for tool in MEMORY_TOOLS_REGISTRY.values() if tool.name in LLM_TOOLS]++# Register default toolsregister_tool(MemoryReadTool())diff --git a/tests/session/memory/test_memory_isolation_handler.py b/tests/session/memory/test_memory_isolation_handler.pyindex b97e02a9d..e54dbfc40 100644--- a/tests/session/memory/test_memory_isolation_handler.py+++ b/tests/session/memory/test_memory_isolation_handler.py@@ -54,8 +54,8 @@ def create_mock_extract_context(messages):return mock_ctx-class TestLoadParticipants:- """Tests for load_participants."""+class TestGetReadScope:+ """Tests for get_read_scope."""def test_single_user_single_agent(self):"""Test extracting single user and agent."""@@ -66,10 +66,11 @@ class TestLoadParticipants:]extract_ctx = create_mock_extract_context(messages)handler = MemoryIsolationHandler(ctx, extract_ctx)- handler.load_participants()- assert handler.get_participant_user_ids() == ["user_a"]- assert handler.get_participant_agent_ids() == ["agent_a"]+ scope = handler.get_read_scope()++ assert scope.user_ids == ["user_a"]+ assert scope.agent_ids == ["agent_a"]def test_multiple_users(self):"""Test extracting multiple users."""@@ -81,10 +82,11 @@ class TestLoadParticipants:]extract_ctx = create_mock_extract_context(messages)handler = MemoryIsolationHandler(ctx, extract_ctx)- handler.load_participants()- assert set(handler.get_participant_user_ids()) == {"user_a", "user_b"}- assert handler.get_participant_agent_ids() == ["agent_a"]+ scope = handler.get_read_scope()++ assert set(scope.user_ids) == {"user_a", "user_b"}+ assert scope.agent_ids == ["agent_a"]def test_multiple_agents(self):"""Test extracting multiple agents."""@@ -96,10 +98,11 @@ class TestLoadParticipants:]extract_ctx = create_mock_extract_context(messages)handler = MemoryIsolationHandler(ctx, extract_ctx)- handler.load_participants()- assert handler.get_participant_user_ids() == ["user_a"]- assert set(handler.get_participant_agent_ids()) == {"agent_a", "agent_b"}+ scope = handler.get_read_scope()++ assert scope.user_ids == ["user_a"]+ assert set(scope.agent_ids) == {"agent_a", "agent_b"}def test_deduplicate_users(self):"""Test that duplicate users are deduplicated."""@@ -111,9 +114,10 @@ class TestLoadParticipants:]extract_ctx = create_mock_extract_context(messages)handler = MemoryIsolationHandler(ctx, extract_ctx)- handler.load_participants()- assert handler.get_participant_user_ids() == ["user_a"]+ scope = handler.get_read_scope()++ assert scope.user_ids == ["user_a"]def test_empty_messages_uses_ctx_defaults(self):"""Test that empty messages fall back to ctx defaults."""@@ -121,10 +125,11 @@ class TestLoadParticipants:messages = []extract_ctx = create_mock_extract_context(messages)handler = MemoryIsolationHandler(ctx, extract_ctx)- handler.load_participants()- assert handler.get_participant_user_ids() == ["default_user"]- assert handler.get_participant_agent_ids() == ["default_agent"]+ scope = handler.get_read_scope()++ assert scope.user_ids == ["default_user"]+ assert scope.agent_ids == ["default_agent"]def test_messages_without_role_id_uses_ctx_defaults(self):"""Test that messages without role_id fall back to ctx defaults."""@@ -140,30 +145,19 @@ class TestLoadParticipants:messages = [msg]extract_ctx = create_mock_extract_context(messages)handler = MemoryIsolationHandler(ctx, extract_ctx)- handler.load_participants()- # Should use ctx defaults since no valid role_id found- assert "default_user" in handler.get_participant_user_ids()+ scope = handler.get_read_scope()+ # Should use ctx defaults because no valid role_id found in messages+ assert scope.user_ids == ["default_user"]+ assert scope.agent_ids == ["default_agent"]-class TestValidateRoleId:- """Tests for validate_role_id."""- def test_valid_user_role_id(self):- """Test validating a valid user role_id."""- ctx = create_ctx()- messages = [- create_message("user", "user_a"),- create_message("assistant", "agent_a"),- ]- extract_ctx = create_mock_extract_context(messages)- handler = MemoryIsolationHandler(ctx, extract_ctx)- handler.load_participants()+class TestFillRoleIds:+ """Tests for fill_role_ids."""- assert handler.validate_role_id("user_a", "user") is True-- def test_invalid_user_role_id(self):- """Test validating an invalid user role_id."""+ def test_fill_role_ids_with_specified_values(self):+ """Test fill_role_ids with specified user_id and agent_id."""ctx = create_ctx()messages = [create_message("user", "user_a"),@@ -171,419 +165,76 @@ class TestValidateRoleId:]extract_ctx = create_mock_extract_context(messages)handler = MemoryIsolationHandler(ctx, extract_ctx)- handler.load_participants()+ role_scope = handler.get_read_scope()- assert handler.validate_role_id("user_b", "user") is False+ item_dict = {"user_id": "user_a", "agent_id": "agent_a"}+ handler.fill_role_ids(item_dict, role_scope)- def test_valid_agent_role_id(self):- """Test validating a valid agent role_id."""- ctx = create_ctx()- messages = [- create_message("user", "user_a"),- create_message("assistant", "agent_a"),- ]- extract_ctx = create_mock_extract_context(messages)- handler = MemoryIsolationHandler(ctx, extract_ctx)- handler.load_participants()-- assert handler.validate_role_id("agent_a", "agent") is True-- def test_invalid_agent_role_id(self):- """Test validating an invalid agent role_id."""- ctx = create_ctx()- messages = [- create_message("user", "user_a"),- create_message("assistant", "agent_a"),- ]- extract_ctx = create_mock_extract_context(messages)- handler = MemoryIsolationHandler(ctx, extract_ctx)- handler.load_participants()-- assert handler.validate_role_id("agent_b", "agent") is False+ assert item_dict["user_id"] == "user_a"+ assert item_dict["agent_id"] == "agent_a"- def test_get_valid_role_ids(self):- """Test getting valid role_ids."""+ def test_fill_role_ids_without_values_uses_default(self):+ """Test fill_role_ids without values uses first in scope."""ctx = create_ctx()messages = [create_message("user", "user_a"),create_message("user", "user_b"),create_message("assistant", "agent_a"),+ create_message("assistant", "agent_b"),]extract_ctx = create_mock_extract_context(messages)handler = MemoryIsolationHandler(ctx, extract_ctx)- handler.load_participants()-- assert handler.get_valid_role_ids("user") == ["user_a", "user_b"]- assert handler.get_valid_role_ids("agent") == ["agent_a"]---class TestCalculateUserSpace:- """Tests for _calculate_user_space."""-- def test_user_space_no_isolation(self):- """Test user_space when isolate_user_scope_by_agent is false."""- ctx = create_ctx(isolate_user_by_agent=False)- extract_ctx = create_mock_extract_context([])- handler = MemoryIsolationHandler(ctx, extract_ctx)-- assert handler._calculate_user_space("user_a") == "user_a"-- def test_user_space_with_isolation(self):- """Test user_space when isolate_user_scope_by_agent is true."""- ctx = create_ctx(isolate_user_by_agent=True, user_id="user_a", agent_id="agent_x")- extract_ctx = create_mock_extract_context([])- handler = MemoryIsolationHandler(ctx, extract_ctx)-- assert handler._calculate_user_space("user_a") == "user_a/agent/agent_x"+ role_scope = handler.get_read_scope()+ item_dict = {}+ handler.fill_role_ids(item_dict, role_scope)-class TestCalculateAgentSpace:- """Tests for _calculate_agent_space."""-- def test_agent_space_no_isolation(self):- """Test agent_space when isolate_agent_scope_by_user is false."""- ctx = create_ctx(isolate_agent_by_user=False)- extract_ctx = create_mock_extract_context([])- handler = MemoryIsolationHandler(ctx, extract_ctx)-- assert handler._calculate_agent_space("agent_a") == "agent_a"-- def test_agent_space_with_isolation(self):- """Test agent_space when isolate_agent_scope_by_user is true."""- ctx = create_ctx(isolate_agent_by_user=True, user_id="user_x", agent_id="agent_a")- extract_ctx = create_mock_extract_context([])- handler = MemoryIsolationHandler(ctx, extract_ctx)-- assert handler._calculate_agent_space("agent_a") == "agent_a/user/user_x"---class TestCalculateTargetForRole:- """Tests for _calculate_target_for_role."""-- def test_user_target_no_isolation(self):- """Test user target when isolate_user_scope_by_agent is false."""- ctx = create_ctx(- user_id="user_a",- agent_id="agent_a",- isolate_user_by_agent=False,- )- messages = [create_message("user", "user_a")]- extract_ctx = create_mock_extract_context(messages)- handler = MemoryIsolationHandler(ctx, extract_ctx)- handler.load_participants()-- target = handler._calculate_target_for_role("user_a", "user", "preferences")-- assert target.uri == "viking://user/user_a/memories/preferences"- assert target.owner_user_id == "user_a"- assert target.owner_agent_id is None-- def test_user_target_with_isolation(self):- """Test user target when isolate_user_scope_by_agent is true."""- ctx = create_ctx(- user_id="user_a",- agent_id="agent_x",- isolate_user_by_agent=True,- )- messages = [create_message("user", "user_a")]- extract_ctx = create_mock_extract_context(messages)- handler = MemoryIsolationHandler(ctx, extract_ctx)- handler.load_participants()-- target = handler._calculate_target_for_role("user_a", "user", "preferences")-- assert target.uri == "viking://user/user_a/agent/agent_x/memories/preferences"- assert target.owner_user_id == "user_a"- assert target.owner_agent_id == "agent_x"-- def test_agent_target_no_isolation(self):- """Test agent target when isolate_agent_scope_by_user is false."""- ctx = create_ctx(- user_id="user_a",- agent_id="agent_a",- isolate_agent_by_user=False,- )- messages = [create_message("assistant", "agent_a")]- extract_ctx = create_mock_extract_context(messages)- handler = MemoryIsolationHandler(ctx, extract_ctx)- handler.load_participants()-- target = handler._calculate_target_for_role("agent_a", "agent", "skills")-- assert target.uri == "viking://agent/agent_a/memories/skills"- assert target.owner_agent_id == "agent_a"- assert target.owner_user_id is None-- def test_agent_target_with_isolation(self):- """Test agent target when isolate_agent_scope_by_user is true."""- ctx = create_ctx(- user_id="user_x",- agent_id="agent_a",- isolate_agent_by_user=True,- )- messages = [create_message("assistant", "agent_a")]- extract_ctx = create_mock_extract_context(messages)- handler = MemoryIsolationHandler(ctx, extract_ctx)- handler.load_participants()-- target = handler._calculate_target_for_role("agent_a", "agent", "skills")-- assert target.uri == "viking://agent/agent_a/user/user_x/memories/skills"- assert target.owner_agent_id == "agent_a"- assert target.owner_user_id == "user_x"---class TestCalculateMemoryTargets:- """Tests for calculate_memory_targets."""-- def test_single_target_no_role_id(self):- """Test single target when role_id is None (use ctx default)."""- ctx = create_ctx(user_id="user_a", agent_id="agent_a")- messages = [create_message("user", "user_a")]- extract_ctx = create_mock_extract_context(messages)- handler = MemoryIsolationHandler(ctx, extract_ctx)- handler.load_participants()-- targets = handler.calculate_memory_targets(- role_id=None,- role_type="user",- memory_type="preferences",- )+ assert item_dict["user_id"] in ["user_a", "user_b"]+ assert item_dict["agent_id"] in ["agent_a", "agent_b"]- assert len(targets) == 1- assert targets[0].owner_user_id == "user_a"-- def test_single_target_with_valid_role_id(self):- """Test single target with valid role_id."""- ctx = create_ctx(user_id="user_a", agent_id="agent_a")+ def test_fill_role_ids_invalid_user_id_ignored(self):+ """Test invalid user_id is ignored, uses default."""+ ctx = create_ctx()messages = [create_message("user", "user_a"),- create_message("user", "user_b"),+ create_message("assistant", "agent_a"),]extract_ctx = create_mock_extract_context(messages)handler = MemoryIsolationHandler(ctx, extract_ctx)- handler.load_participants()+ role_scope = handler.get_read_scope()- targets = handler.calculate_memory_targets(- role_id="user_b",- role_type="user",- memory_type="preferences",- )-- assert len(targets) == 1- assert targets[0].owner_user_id == "user_b"-- def test_single_target_with_invalid_role_id(self):- """Test single target with invalid role_id raises error."""- ctx = create_ctx(user_id="user_a", agent_id="agent_a")- messages = [create_message("user", "user_a")]- extract_ctx = create_mock_extract_context(messages)- handler = MemoryIsolationHandler(ctx, extract_ctx)- handler.load_participants()-- with pytest.raises(ValueError) as exc_info:- handler.calculate_memory_targets(- role_id="user_invalid",- role_type="user",- memory_type="preferences",- )-- assert "user_invalid" in str(exc_info.value)- assert "not in session participants" in str(exc_info.value)-- def test_events_multiple_targets(self):- """Test events type returns multiple targets."""- ctx = create_ctx(- user_id="user_a",- agent_id="agent_a",- )- messages = [- create_message("user", "user_a"),- create_message("user", "user_b"),- create_message("user", "user_c"),- ]- extract_ctx = create_mock_extract_context(messages)- handler = MemoryIsolationHandler(ctx, extract_ctx)- handler.load_participants()+ item_dict = {"user_id": "invalid_user", "agent_id": "agent_a"}+ handler.fill_role_ids(item_dict, role_scope)- # events without explicit operation uses all user participants- targets = handler.calculate_memory_targets(- role_id=None,- role_type="user",- memory_type="events",- )+ assert item_dict["user_id"] == "user_a" # fallback to default+ assert item_dict["agent_id"] == "agent_a"- assert len(targets) == 3- owner_ids = [t.owner_user_id for t in targets]- assert "user_a" in owner_ids- assert "user_b" in owner_ids- assert "user_c" in owner_ids-- def test_operation_with_user_id_field(self):- """Test operation with user_id field returns single target."""- ctx = create_ctx(- user_id="user_a",- agent_id="agent_a",- )+ def test_fill_role_ids_with_ranges(self):+ """Test fill_role_ids with ranges extracts from messages."""+ ctx = create_ctx()messages = [create_message("user", "user_a"),+ create_message("assistant", "agent_a"),create_message("user", "user_b"),+ create_message("assistant", "agent_b"),]extract_ctx = create_mock_extract_context(messages)- handler = MemoryIsolationHandler(ctx, extract_ctx)- handler.load_participants()-- # operation with user_id field- operation = {"user_id": "user_b"}- targets = handler.calculate_memory_targets(- role_id=None,- role_type="user",- memory_type="preferences",- operation=operation,- )- assert len(targets) == 1- assert targets[0].owner_user_id == "user_b"+ # Mock read_message_ranges+ mock_range = MagicMock()+ mock_range.elements = [messages]+ extract_ctx.read_message_ranges.return_value = mock_range- def test_operation_with_ranges_field(self):- """Test operation with ranges field extracts user_ids from range."""- ctx = create_ctx(- user_id="user_a",- agent_id="agent_a",- )- messages = [- create_message("user", "user_a"),- create_message("user", "user_b"),- create_message("user", "user_c"),- ]- extract_ctx = create_mock_extract_context(messages)- handler = MemoryIsolationHandler(ctx, extract_ctx)- handler.load_participants()-- # Mock _extract_role_ids_from_events_range to return specific user_ids- with patch.object(- handler,- "_extract_role_ids_from_events_range",- return_value=["user_a", "user_c"],- ):- operation = {"ranges": "0-1"}- targets = handler.calculate_memory_targets(- role_id=None,- role_type="user",- memory_type="events",- operation=operation,- )-- assert len(targets) == 2- owner_ids = [t.owner_user_id for t in targets]- assert "user_a" in owner_ids- assert "user_c" in owner_ids---class TestNamespacePolicyCombinations:- """Tests for all four namespace policy combinations."""-- def test_policy_false_false(self):- """Test: isolate_user=false, isolate_agent=false"""- ctx = create_ctx(- user_id="user_a",- agent_id="agent_x",- isolate_user_by_agent=False,- isolate_agent_by_user=False,- )- messages = [- create_message("user", "user_a"),- create_message("assistant", "agent_x"),- ]- extract_ctx = create_mock_extract_context(messages)- handler = MemoryIsolationHandler(ctx, extract_ctx)- handler.load_participants()-- # User target- user_target = handler._calculate_target_for_role("user_a", "user", "preferences")- assert user_target.uri == "viking://user/user_a/memories/preferences"- assert user_target.owner_user_id == "user_a"- assert user_target.owner_agent_id is None-- # Agent target- agent_target = handler._calculate_target_for_role("agent_x", "agent", "skills")- assert agent_target.uri == "viking://agent/agent_x/memories/skills"- assert agent_target.owner_agent_id == "agent_x"- assert agent_target.owner_user_id is None-- def test_policy_false_true(self):- """Test: isolate_user=false, isolate_agent=true"""- ctx = create_ctx(- user_id="user_a",- agent_id="agent_x",- isolate_user_by_agent=False,- isolate_agent_by_user=True,- )- messages = [- create_message("user", "user_a"),- create_message("assistant", "agent_x"),- ]- extract_ctx = create_mock_extract_context(messages)- handler = MemoryIsolationHandler(ctx, extract_ctx)- handler.load_participants()-- # User target (no isolation)- user_target = handler._calculate_target_for_role("user_a", "user", "preferences")- assert user_target.uri == "viking://user/user_a/memories/preferences"-- # Agent target (isolated by user)- agent_target = handler._calculate_target_for_role("agent_x", "agent", "skills")- assert agent_target.uri == "viking://agent/agent_x/user/user_a/memories/skills"- assert agent_target.owner_user_id == "user_a"-- def test_policy_true_false(self):- """Test: isolate_user=true, isolate_agent=false"""- ctx = create_ctx(- user_id="user_a",- agent_id="agent_x",- isolate_user_by_agent=True,- isolate_agent_by_user=False,- )- messages = [- create_message("user", "user_a"),- create_message("assistant", "agent_x"),- ]- extract_ctx = create_mock_extract_context(messages)- handler = MemoryIsolationHandler(ctx, extract_ctx)- handler.load_participants()-- # User target (isolated by agent)- user_target = handler._calculate_target_for_role("user_a", "user", "preferences")- assert user_target.uri == "viking://user/user_a/agent/agent_x/memories/preferences"- assert user_target.owner_agent_id == "agent_x"-- # Agent target (no isolation)- agent_target = handler._calculate_target_for_role("agent_x", "agent", "skills")- assert agent_target.uri == "viking://agent/agent_x/memories/skills"-- def test_policy_true_true(self):- """Test: isolate_user=true, isolate_agent=true"""- ctx = create_ctx(- user_id="user_a",- agent_id="agent_x",- isolate_user_by_agent=True,- isolate_agent_by_user=True,- )- messages = [- create_message("user", "user_a"),- create_message("assistant", "agent_x"),- ]- extract_ctx = create_mock_extract_context(messages)handler = MemoryIsolationHandler(ctx, extract_ctx)- handler.load_participants()+ role_scope = handler.get_read_scope()- # User target (isolated by agent)- user_target = handler._calculate_target_for_role("user_a", "user", "preferences")- assert user_target.uri == "viking://user/user_a/agent/agent_x/memories/preferences"+ item_dict = {"ranges": "0-3"}+ handler.fill_role_ids(item_dict, role_scope)- # Agent target (isolated by user)- agent_target = handler._calculate_target_for_role("agent_x", "agent", "skills")- assert agent_target.uri == "viking://agent/agent_x/user/user_a/memories/skills"+ assert "user_ids" in item_dict+ assert "agent_ids" in item_dict+ assert set(item_dict["user_ids"]) == {"user_a", "user_b"}+ assert set(item_dict["agent_ids"]) == {"agent_a", "agent_b"}class TestPrepareMessages:@@ -629,7 +280,7 @@ class TestPrepareMessages:assert messages[1].role_id == "agent_a"@patch("openviking.session.memory.memory_isolation_handler.get_openviking_config")- def test_get_read_scope_uses_login_user_when_disabled(self, mock_config):+ def test_get_read_scope_with_prepare_disabled(self, mock_config):"""开关关闭时,get_read_scope 只返回登录用户(因为 role_id 被清空)。"""mock_memory_config = MagicMock()mock_memory_config.enable_role_id_memory_isolate = False@@ -649,7 +300,7 @@ class TestPrepareMessages:assert scope.agent_ids == ["login_agent"]@patch("openviking.session.memory.memory_isolation_handler.get_openviking_config")- def test_get_read_scope_uses_role_ids_when_enabled(self, mock_config):+ def test_get_read_scope_with_prepare_enabled(self, mock_config):"""开关开启时,get_read_scope 从 message role_id 提取参与者。"""mock_memory_config = MagicMock()mock_memory_config.enable_role_id_memory_isolate = True@@ -682,3 +333,66 @@ class TestPrepareMessages:handler.prepare_messages()assert messages[0].role_id is None+++class TestCalculateMemoryUris:+ """Tests for calculate_memory_uris (integration with URI generation)."""++ @patch("openviking.session.memory.memory_isolation_handler.generate_uri")+ def test_calculate_memory_uris_single_user_agent(self, mock_generate_uri):+ """Test calculate_memory_uris with single user and agent."""+ mock_generate_uri.return_value = "viking://user/user_a/memories/preferences"++ ctx = create_ctx()+ messages = [create_message("user", "user_a")]+ extract_ctx = create_mock_extract_context(messages)+ handler = MemoryIsolationHandler(ctx, extract_ctx)++ from openviking.session.memory.dataclass import MemoryTypeSchema, ResolvedOperation++ schema = MemoryTypeSchema(+ memory_type="preferences",+ filename_template="preferences.md",+ directory="viking://user/{user_space}/memories",+ )++ operation = ResolvedOperation(+ old_memory_file_content=None,+ memory_fields={"user_id": "user_a", "agent_id": "agent_a"},+ memory_type="preferences",+ uris=[],+ )++ uris = handler.calculate_memory_uris(schema, operation, extract_ctx)++ assert len(uris) == 1+ assert "user_a" in uris[0]++ @patch("openviking.session.memory.memory_isolation_handler.generate_uri")+ def test_calculate_memory_uris_multiple_users_agents(self, mock_generate_uri):+ """Test calculate_memory_uris with multiple users and agents."""+ mock_generate_uri.side_effect = lambda **kwargs: f"viking://user/{kwargs.get('user_space')}/memories/test"++ ctx = create_ctx()+ messages = [create_message("user", "user_a")]+ extract_ctx = create_mock_extract_context(messages)+ handler = MemoryIsolationHandler(ctx, extract_ctx)++ from openviking.session.memory.dataclass import MemoryTypeSchema, ResolvedOperation++ schema = MemoryTypeSchema(+ memory_type="test",+ filename_template="test.md",+ directory="viking://user/{user_space}/memories",+ )++ operation = ResolvedOperation(+ old_memory_file_content=None,+ memory_fields={"user_ids": ["user_a", "user_b"], "agent_ids": ["agent_a", "agent_b"]},+ memory_type="test",+ uris=[],+ )++ uris = handler.calculate_memory_uris(schema, operation, extract_ctx)++ assert len(uris) == 4 # 2 users * 2 agentsdiff --git a/tests/session/memory/test_memory_tools.py b/tests/session/memory/test_memory_tools.pyindex b979424b2..fc9eac81e 100644--- a/tests/session/memory/test_memory_tools.py+++ b/tests/session/memory/test_memory_tools.py@@ -12,8 +12,8 @@ from openviking.session.memory.tools import (MemoryReadTool,MemorySearchTool,get_tool,- get_tool_schemas,list_tools,+ get_tool_schemas,)from openviking_cli.session.user_id import UserIdentifier@@ -77,14 +77,16 @@ class TestMemoryTools:),role=Role.USER,)+ viking_fs = MockVikingFS()+ # Create tool_ctx with viking_fs includedtool_ctx = ToolContext(+ viking_fs=viking_fs,request_ctx=request_ctx,default_search_uris=["viking://user/test-account/test-user/memories"],+ read_file_contents={},)- viking_fs = MockVikingFS()result = await MemorySearchTool().execute(- viking_fs,tool_ctx,query="profile",limit=2,diff --git a/uv.lock b/uv.lockindex d1a92ac01..9605a6786 100644--- a/uv.lock+++ b/uv.lock@@ -733,14 +733,14 @@ wheels = [[[package]]name = "click"-version = "8.3.1"+version = "8.1.8"source = { registry = "https://pypi.org/simple" }dependencies = [{ name = "colorama", marker = "sys_platform == 'win32'" },]-sdist = { url = "https://files.pythonhosted.org/packages/3d/fa/656b739db8587d7b5dfa22e22ed02566950fbfbcdc20311993483657a5c0/click-8.3.1.tar.gz", hash = "sha256:12ff4785d337a1bb490bb7e9c2b1ee5da3112e94a8622f26a6c77f5d2fc6842a", size = 295065, upload-time = "2025-11-15T20:45:42.706Z" }+sdist = { url = "https://files.pythonhosted.org/packages/b9/2e/0090cbf739cee7d23781ad4b89a9894a41538e4fcf4c31dcdd705b78eb8b/click-8.1.8.tar.gz", hash = "sha256:ed53c9d8990d83c2a27deae68e4ee337473f6330c040a31d4225c9574d16096a", size = 226593, upload-time = "2024-12-21T18:38:44.339Z" }wheels = [- { url = "https://files.pythonhosted.org/packages/98/78/01c019cdb5d6498122777c1a43056ebb3ebfeef2076d9d026bfe15583b2b/click-8.3.1-py3-none-any.whl", hash = "sha256:981153a64e25f12d547d3426c367a4857371575ee7ad18df2a6183ab0545b2a6", size = 108274, upload-time = "2025-11-15T20:45:41.139Z" },+ { url = "https://files.pythonhosted.org/packages/7e/d4/7ebdbd03970677812aac39c869717059dbb71a4cfc033ca6e5221787892c/click-8.1.8-py3-none-any.whl", hash = "sha256:63c132bbbed01578a06712a2d1f497bb62d9c1c0d329b7903a866228027263b2", size = 98188, upload-time = "2024-12-21T18:38:41.666Z" },][[package]]@@ -1822,14 +1822,14 @@ wheels = [[[package]]name = "importlib-metadata"-version = "8.7.1"+version = "8.5.0"source = { registry = "https://pypi.org/simple" }dependencies = [{ name = "zipp" },]-sdist = { url = "https://files.pythonhosted.org/packages/f3/49/3b30cad09e7771a4982d9975a8cbf64f00d4a1ececb53297f1d9a7be1b10/importlib_metadata-8.7.1.tar.gz", hash = "sha256:49fef1ae6440c182052f407c8d34a68f72efc36db9ca90dc0113398f2fdde8bb", size = 57107, upload-time = "2025-12-21T10:00:19.278Z" }+sdist = { url = "https://files.pythonhosted.org/packages/cd/12/33e59336dca5be0c398a7482335911a33aa0e20776128f038019f1a95f1b/importlib_metadata-8.5.0.tar.gz", hash = "sha256:71522656f0abace1d072b9e5481a48f07c138e00f079c38c8f883823f9c26bd7", size = 55304, upload-time = "2024-09-11T14:56:08.937Z" }wheels = [- { url = "https://files.pythonhosted.org/packages/fa/5e/f8e9a1d23b9c20a551a8a02ea3637b4642e22c2626e3a13a9a29cdea99eb/importlib_metadata-8.7.1-py3-none-any.whl", hash = "sha256:5a1f80bf1daa489495071efbb095d75a634cf28a8bc299581244063b53176151", size = 27865, upload-time = "2025-12-21T10:00:18.329Z" },+ { url = "https://files.pythonhosted.org/packages/a0/d9/a1e041c5e7caa9a05c925f4bdbdfb7f006d1f74996af53467bc394c97be7/importlib_metadata-8.5.0-py3-none-any.whl", hash = "sha256:45e54197d28b7a7f1559e60b95e7c567032b602131fbd588f1497f47880aa68b", size = 26514, upload-time = "2024-09-11T14:56:07.019Z" },][[package]]@@ -1991,7 +1991,7 @@ wheels = [[[package]]name = "jsonschema"-version = "4.26.0"+version = "4.23.0"source = { registry = "https://pypi.org/simple" }dependencies = [{ name = "attrs" },@@ -1999,9 +1999,9 @@ dependencies = [{ name = "referencing" },{ name = "rpds-py" },]-sdist = { url = "https://files.pythonhosted.org/packages/b3/fc/e067678238fa451312d4c62bf6e6cf5ec56375422aee02f9cb5f909b3047/jsonschema-4.26.0.tar.gz", hash = "sha256:0c26707e2efad8aa1bfc5b7ce170f3fccc2e4918ff85989ba9ffa9facb2be326", size = 366583, upload-time = "2026-01-07T13:41:07.246Z" }+sdist = { url = "https://files.pythonhosted.org/packages/38/2e/03362ee4034a4c917f697890ccd4aec0800ccf9ded7f511971c75451deec/jsonschema-4.23.0.tar.gz", hash = "sha256:d71497fef26351a33265337fa77ffeb82423f3ea21283cd9467bb03999266bc4", size = 325778, upload-time = "2024-07-08T18:40:05.546Z" }wheels = [- { url = "https://files.pythonhosted.org/packages/69/90/f63fb5873511e014207a475e2bb4e8b2e570d655b00ac19a9a0ca0a385ee/jsonschema-4.26.0-py3-none-any.whl", hash = "sha256:d489f15263b8d200f8387e64b4c3a75f06629559fb73deb8fdfb525f2dab50ce", size = 90630, upload-time = "2026-01-07T13:41:05.306Z" },+ { url = "https://files.pythonhosted.org/packages/69/4a/4f9dbeb84e8850557c02365a0eee0649abe5eb1d84af92a25731c6c0f922/jsonschema-4.23.0-py3-none-any.whl", hash = "sha256:fbadb6f8b144a8f8cf9f0b89ba94501d143e50411a1278633f56a7acf7fd5566", size = 88462, upload-time = "2024-07-08T18:40:00.165Z" },][[package]]@@ -2375,7 +2375,7 @@ wheels = [[[package]]name = "litellm"-version = "1.82.0"+version = "1.83.12"source = { registry = "https://pypi.org/simple" }dependencies = [{ name = "aiohttp" },@@ -2391,9 +2391,9 @@ dependencies = [{ name = "tiktoken" },{ name = "tokenizers" },]-sdist = { url = "https://files.pythonhosted.org/packages/6c/00/49bb5c28e0dea0f5086229a2a08d5fdc6c8dc0d8e2acb2a2d1f7dd9f4b70/litellm-1.82.0.tar.gz", hash = "sha256:d388f52447daccbcaafa19a3e68d17b75f1374b5bf2cde680d65e1cd86e50d22", size = 16800355, upload-time = "2026-03-01T02:35:30.363Z" }+sdist = { url = "https://files.pythonhosted.org/packages/9b/c3/7375347f6cedac8d3c7f248dcd694538670e23d01caf5fa16bc1123b9bd3/litellm-1.83.12.tar.gz", hash = "sha256:d5c3c64321b9575169aaf374ebc629dc878a9b449fd20399a1ccdfaa869104ff", size = 14777039, upload-time = "2026-04-23T02:37:47.531Z" }wheels = [- { url = "https://files.pythonhosted.org/packages/28/89/eb28bfcf97d6b045c400e72eb047c381594467048c237dbb6c227764084c/litellm-1.82.0-py3-none-any.whl", hash = "sha256:5496b5d4532cccdc7a095c21cbac4042f7662021c57bc1d17be4e39838929e80", size = 14911978, upload-time = "2026-03-01T02:35:26.844Z" },+ { url = "https://files.pythonhosted.org/packages/a2/4c/93c0d7c65ac110e27f53febd4e3e249bc6a0df6cf8024cd5e0817bc1fedd/litellm-1.83.12-py3-none-any.whl", hash = "sha256:fc906d207423af0be84649ef79516819af6561ad61355984500fd42f095601e4", size = 16397141, upload-time = "2026-04-23T02:37:43.166Z" },][[package]]@@ -3277,7 +3277,7 @@ wheels = [[[package]]name = "openai"-version = "2.26.0"+version = "2.24.0"source = { registry = "https://pypi.org/simple" }dependencies = [{ name = "anyio" },@@ -3289,9 +3289,9 @@ dependencies = [{ name = "tqdm" },{ name = "typing-extensions" },]-sdist = { url = "https://files.pythonhosted.org/packages/d7/91/2a06c4e9597c338cac1e5e5a8dd6f29e1836fc229c4c523529dca387fda8/openai-2.26.0.tar.gz", hash = "sha256:b41f37c140ae0034a6e92b0c509376d907f3a66109935fba2c1b471a7c05a8fb", size = 666702, upload-time = "2026-03-05T23:17:35.874Z" }+sdist = { url = "https://files.pythonhosted.org/packages/55/13/17e87641b89b74552ed408a92b231283786523edddc95f3545809fab673c/openai-2.24.0.tar.gz", hash = "sha256:1e5769f540dbd01cb33bc4716a23e67b9d695161a734aff9c5f925e2bf99a673", size = 658717, upload-time = "2026-02-24T20:02:07.958Z" }wheels = [- { url = "https://files.pythonhosted.org/packages/c6/2e/3f73e8ca53718952222cacd0cf7eecc9db439d020f0c1fe7ae717e4e199a/openai-2.26.0-py3-none-any.whl", hash = "sha256:6151bf8f83802f036117f06cc8a57b3a4da60da9926826cc96747888b57f394f", size = 1136409, upload-time = "2026-03-05T23:17:34.072Z" },+ { url = "https://files.pythonhosted.org/packages/c9/30/844dc675ee6902579b8eef01ed23917cc9319a1c9c0c14ec6e39340c96d0/openai-2.24.0-py3-none-any.whl", hash = "sha256:fed30480d7d6c884303287bde864980a4b137b60553ffbcf9ab4a233b7a73d94", size = 1120122, upload-time = "2026-02-24T20:02:05.669Z" },][[package]]@@ -3733,7 +3733,7 @@ requires-dist = [{ name = "langfuse", marker = "extra == 'bot-langfuse'", specifier = ">=3.0.0" },{ name = "lark-oapi", specifier = ">=1.5.3" },{ name = "lark-oapi", marker = "extra == 'bot-feishu'", specifier = ">=1.0.0" },- { name = "litellm", specifier = ">=1.0.0,<1.83.13" },+ { name = "litellm", specifier = ">=1.83.7,<1.83.13" },{ name = "llama-cpp-python", marker = "extra == 'local-embed'", specifier = ">=0.3.0" },{ name = "loguru", specifier = ">=0.7.3" },{ name = "markdownify", specifier = ">=0.11.0" },@@ -3771,7 +3771,7 @@ requires-dist = [{ name = "pytest-asyncio", marker = "extra == 'test'", specifier = ">=0.21.0" },{ name = "pytest-cov", marker = "extra == 'test'", specifier = ">=4.0.0" },{ name = "python-docx", specifier = ">=1.0.0" },- { name = "python-multipart", specifier = ">=0.0.22" },+ { name = "python-multipart", specifier = ">=0.0.27" },{ name = "python-pptx", specifier = ">=1.0.0" },{ name = "python-socketio", marker = "extra == 'bot'", specifier = ">=5.11.0" },{ name = "python-socks", extras = ["asyncio"], marker = "extra == 'bot'", specifier = ">=2.4.0" },@@ -4878,11 +4878,11 @@ wheels = [[[package]]name = "python-dotenv"-version = "1.2.2"+version = "1.0.1"source = { registry = "https://pypi.org/simple" }-sdist = { url = "https://files.pythonhosted.org/packages/82/ed/0301aeeac3e5353ef3d94b6ec08bbcabd04a72018415dcb29e588514bba8/python_dotenv-1.2.2.tar.gz", hash = "sha256:2c371a91fbd7ba082c2c1dc1f8bf89ca22564a087c2c287cd9b662adde799cf3", size = 50135, upload-time = "2026-03-01T16:00:26.196Z" }+sdist = { url = "https://files.pythonhosted.org/packages/bc/57/e84d88dfe0aec03b7a2d4327012c1627ab5f03652216c63d49846d7a6c58/python-dotenv-1.0.1.tar.gz", hash = "sha256:e324ee90a023d808f1959c46bcbc04446a10ced277783dc6ee09987c37ec10ca", size = 39115, upload-time = "2024-01-23T06:33:00.505Z" }wheels = [- { url = "https://files.pythonhosted.org/packages/0b/d7/1959b9648791274998a9c3526f6d0ec8fd2233e4d4acce81bbae76b44b2a/python_dotenv-1.2.2-py3-none-any.whl", hash = "sha256:1d8214789a24de455a8b8bd8ae6fe3c6b69a5e3d64aa8a8e5d68e694bbcb285a", size = 22101, upload-time = "2026-03-01T16:00:25.09Z" },+ { url = "https://files.pythonhosted.org/packages/6a/3e/b68c118422ec867fa7ab88444e1274aa40681c606d59ac27de5a5588f082/python_dotenv-1.0.1-py3-none-any.whl", hash = "sha256:f7b63ef50f1b690dddf550d03497b66d609393b40b564ed0d674909a68ebf16a", size = 19863, upload-time = "2024-01-23T06:32:58.246Z" },][[package]]@@ -4899,11 +4899,11 @@ wheels = [[[package]]name = "python-multipart"-version = "0.0.22"+version = "0.0.27"source = { registry = "https://pypi.org/simple" }-sdist = { url = "https://files.pythonhosted.org/packages/94/01/979e98d542a70714b0cb2b6728ed0b7c46792b695e3eaec3e20711271ca3/python_multipart-0.0.22.tar.gz", hash = "sha256:7340bef99a7e0032613f56dc36027b959fd3b30a787ed62d310e951f7c3a3a58", size = 37612, upload-time = "2026-01-25T10:15:56.219Z" }+sdist = { url = "https://files.pythonhosted.org/packages/69/9b/f23807317a113dc36e74e75eb265a02dd1a4d9082abc3c1064acd22997c4/python_multipart-0.0.27.tar.gz", hash = "sha256:9870a6a8c5a20a5bf4f07c017bd1489006ff8836cff097b6933355ee2b49b602", size = 44043, upload-time = "2026-04-27T10:51:26.649Z" }wheels = [- { url = "https://files.pythonhosted.org/packages/1b/d0/397f9626e711ff749a95d96b7af99b9c566a9bb5129b8e4c10fc4d100304/python_multipart-0.0.22-py3-none-any.whl", hash = "sha256:2b2cd894c83d21bf49d702499531c7bafd057d730c201782048f7945d82de155", size = 24579, upload-time = "2026-01-25T10:15:54.811Z" },+ { url = "https://files.pythonhosted.org/packages/99/78/4126abcbdbd3c559d43e0db7f7b9173fc6befe45d39a2856cc0b8ec2a5a6/python_multipart-0.0.27-py3-none-any.whl", hash = "sha256:6fccfad17a27334bd0193681b369f476eda3409f17381a2d65aa7df3f7275645", size = 29254, upload-time = "2026-04-27T10:51:24.997Z" },][[package]]@@ -6299,7 +6299,7 @@ wheels = [[[package]]name = "typer"-version = "0.24.1"+version = "0.23.1"source = { registry = "https://pypi.org/simple" }dependencies = [{ name = "annotated-doc" },@@ -6307,9 +6307,9 @@ dependencies = [{ name = "rich" },{ name = "shellingham" },]-sdist = { url = "https://files.pythonhosted.org/packages/f5/24/cb09efec5cc954f7f9b930bf8279447d24618bb6758d4f6adf2574c41780/typer-0.24.1.tar.gz", hash = "sha256:e39b4732d65fbdcde189ae76cf7cd48aeae72919dea1fdfc16593be016256b45", size = 118613, upload-time = "2026-02-21T16:54:40.609Z" }+sdist = { url = "https://files.pythonhosted.org/packages/fd/07/b822e1b307d40e263e8253d2384cf98c51aa2368cc7ba9a07e523a1d964b/typer-0.23.1.tar.gz", hash = "sha256:2070374e4d31c83e7b61362fd859aa683576432fd5b026b060ad6b4cd3b86134", size = 120047, upload-time = "2026-02-13T10:04:30.984Z" }wheels = [- { url = "https://files.pythonhosted.org/packages/4a/91/48db081e7a63bb37284f9fbcefda7c44c277b18b0e13fbc36ea2335b71e6/typer-0.24.1-py3-none-any.whl", hash = "sha256:112c1f0ce578bfb4cab9ffdabc68f031416ebcc216536611ba21f04e9aa84c9e", size = 56085, upload-time = "2026-02-21T16:54:41.616Z" },+ { url = "https://files.pythonhosted.org/packages/d5/91/9b286ab899c008c2cb05e8be99814807e7fbbd33f0c0c960470826e5ac82/typer-0.23.1-py3-none-any.whl", hash = "sha256:3291ad0d3c701cbf522012faccfbb29352ff16ad262db2139e6b01f15781f14e", size = 56813, upload-time = "2026-02-13T10:04:32.008Z" },][[package]]