Skip to content

Self-evolving Context Database for AI Agents. Unify Agent Memory, Knowledge RAG and Skills.

Feat/memory isolation (#1905)

chenjw99ae8fea710e
diff --git a/openviking/prompts/templates/memory/events.yaml b/openviking/prompts/templates/memory/events.yaml
index 8b23469f1..e1a6d66a1 100644
--- a/openviking/prompts/templates/memory/events.yaml
+++ b/openviking/prompts/templates/memory/events.yaml
@@ -32,14 +32,15 @@ fields:
- name: event_name
type: string
description: |
- 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: goal
diff --git a/openviking/server/identity.py b/openviking/server/identity.py
index 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: VikingFS
request_ctx: RequestContext
default_search_uris: List[str] = field(default_factory=list)
diff --git a/openviking/session/compressor_v2.py b/openviking/session/compressor_v2.py
index 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] = op
delete_by_uri = {dc.uri: dc for dc in operations.delete_file_contents}
# Process written_uris - distinguish between add and update
diff --git a/openviking/session/memory/__init__.py b/openviking/session/memory/__init__.py
index 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.py
index 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 shown
for 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_content
break
diff --git a/openviking/session/memory/memory_updater.py b/openviking/session/memory/memory_updater.py
index 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_type
schema = 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 independently
for 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.py
index 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_point
right_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_chunk
left_index -= 1
if 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_chunk
right_index += 1
return {
@@ -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 content
line_ending = "\r\n" if "\r\n" in original_content else "\n"
result_lines = re.split(r"\r?\n", original_content)
- delta = 0
diff_results = []
applied_count = 0
- # Sort replacements by start_line
+ # Sort replacements by startLine
replacements = [
{
- "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 += 1
final_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 cases
strategy = 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 content
line_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_line
replacements = [
{
- "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 line
current_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.py
index 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: ignore
Field(
- 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.py
index 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 parameters
Returns:
@@ -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 tools
register_tool(MemoryReadTool())
diff --git a/tests/session/memory/test_memory_isolation_handler.py b/tests/session/memory/test_memory_isolation_handler.py
index 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 agents
diff --git a/tests/session/memory/test_memory_tools.py b/tests/session/memory/test_memory_tools.py
index 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 included
tool_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.lock
index 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]]