Skip to content

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

fix(memory): event_overview_refresh_bug (#2678)

fujiajie666ccb2924011f6
diff --git a/openviking/prompts/templates/memory/entities.yaml b/openviking/prompts/templates/memory/entities.yaml
index 2e4c5c0ea..4c1a4db94 100644
--- a/openviking/prompts/templates/memory/entities.yaml
+++ b/openviking/prompts/templates/memory/entities.yaml
@@ -15,9 +15,9 @@ embedding_template: |-
overview_template: |-
# Entities Overview
- {% if items %}**Category:** {{ items[0].file_content.category }}{% endif %}
+ {% if items %}**Category:** {{ items[0].file_content.category|default(directory_name, true) }}{% endif %}
{% for item in items %}
- - [{{ item.file_content.name }}](./{{ item.file_name }})
+ - [{{ item.file_content.name|default(item.file_name, true) }}](./{{ item.file_name }})
{% endfor %}
fields:
diff --git a/openviking/prompts/templates/memory/events.yaml b/openviking/prompts/templates/memory/events.yaml
index 1cb6c1f9f..7837cdc97 100644
--- a/openviking/prompts/templates/memory/events.yaml
+++ b/openviking/prompts/templates/memory/events.yaml
@@ -107,9 +107,8 @@ embedding_template: |-
{{ content }}
overview_template: |-
# Events Overview
- {% if items %}**Date:** {{ extract_context.get_year(items[0].file_content.ranges|default(''))|default('') }}/{{ extract_context.get_month(items[0].file_content.ranges|default(''))|default('') }}/{{ extract_context.get_day(items[0].file_content.ranges|default(''))|default('') }}{% endif %}
{% for item in items %}
- - [{{ item.file_content.summary }}](./{{ item.file_name }})
+ - [{{ item.file_content.summary|default(item.file_name, true) }}](./{{ item.file_name }})
{% endfor %}
fields:
diff --git a/openviking/prompts/templates/memory/preferences.yaml b/openviking/prompts/templates/memory/preferences.yaml
index 6c89a5386..65bbfadb4 100644
--- a/openviking/prompts/templates/memory/preferences.yaml
+++ b/openviking/prompts/templates/memory/preferences.yaml
@@ -20,10 +20,10 @@ embedding_template: |-
overview_template: |-
# Preferences Overview
- {% if items %}**User:** {{ items[0].file_content.user }}
- **Topic:** {{ items[0].file_content.topic }}{% endif %}
+ {% if items %}**User:** {{ items[0].file_content.user|default(directory_name, true) }}
+ **Topic:** {{ items[0].file_content.topic|default(items[0].file_name, true) }}{% endif %}
{% for item in items %}
- - [{{ item.file_content.topic }}](./{{ item.file_name }})
+ - [{{ item.file_content.topic|default(item.file_name, true) }}](./{{ item.file_name }})
{% endfor %}
fields:
diff --git a/openviking/service/resource_memory_link_service.py b/openviking/service/resource_memory_link_service.py
index 07a311ff5..5280f1ede 100644
--- a/openviking/service/resource_memory_link_service.py
+++ b/openviking/service/resource_memory_link_service.py
@@ -9,6 +9,7 @@ files' MEMORY_FIELDS metadata.
from __future__ import annotations
import asyncio
+import re
from dataclasses import dataclass
from datetime import datetime, timezone
from typing import TYPE_CHECKING, Any, Dict, List, Optional, Sequence
@@ -24,16 +25,13 @@ from openviking.core.peer_id import normalize_peer_id
from openviking.message.part import TextPart
from openviking.server.identity import RequestContext
from openviking.session.memory.dataclass import MemoryFile
-from openviking.session.memory.memory_updater import (
- MemoryUpdater,
- MemoryUpdateResult,
-)
+from openviking.session.memory.memory_updater import MemoryUpdateResult
from openviking.session.memory.utils.memory_file_utils import MemoryFileUtils
from openviking.session.memory.utils.resource_refs import (
content_references_resource,
extract_resource_uris,
- remove_resource_references_from_memory,
resource_ref_matches,
+ unlink_resource_references_from_memory,
)
from openviking.storage import VikingDBManager
from openviking.storage.viking_fs import VikingFS, get_viking_fs
@@ -47,6 +45,7 @@ logger = get_logger(__name__)
_RESOURCE_REASON_SESSION_ID = "__openviking_resource_reason__"
_RESOURCE_REASON_MEMORY_TYPES = ["entities", "events", "preferences"]
+_RESOURCE_DELETION_MEMORY_TYPES = ["entities", "preferences"]
_RESOURCE_REASON_COMMIT_TIMEOUT_SECONDS = 1800.0
_RESOURCE_ABSTRACT_MAX_CHARS = 200
_ABSTRACT_NOT_READY_MARKERS = (
@@ -55,15 +54,34 @@ _ABSTRACT_NOT_READY_MARKERS = (
)
-def _resource_reason_memory_policy(target_peer_id: Optional[str] = None) -> Dict[str, Any]:
+def _resource_memory_policy(
+ *,
+ memory_types: Sequence[str],
+ target_peer_id: Optional[str] = None,
+) -> Dict[str, Any]:
peer_targeted = bool(target_peer_id)
return {
"self": {"enabled": not peer_targeted},
"peer": {"enabled": peer_targeted},
- "memory_types": list(_RESOURCE_REASON_MEMORY_TYPES),
+ "memory_types": list(memory_types),
}
+def _resource_reason_memory_policy(target_peer_id: Optional[str] = None) -> Dict[str, Any]:
+ return _resource_memory_policy(
+ memory_types=_RESOURCE_REASON_MEMORY_TYPES,
+ target_peer_id=target_peer_id,
+ )
+
+
+def _resource_deletion_memory_policy(target_peer_id: Optional[str] = None) -> Dict[str, Any]:
+ # Events are append-only, so deletion commits update only mutable memory types.
+ return _resource_memory_policy(
+ memory_types=_RESOURCE_DELETION_MEMORY_TYPES,
+ target_peer_id=target_peer_id,
+ )
+
+
def _resource_reason_peer_id(ctx: RequestContext, resource_uri: str) -> Optional[str]:
actor_peer_id = normalize_peer_id(ctx.actor_peer_id)
if actor_peer_id:
@@ -197,6 +215,72 @@ class ResourceMemoryLinkService:
"commit_task": task_result,
}
+ async def on_resource_deleted(
+ self,
+ *,
+ ctx: RequestContext,
+ resource_uri: str,
+ memory_uris: Sequence[str],
+ recursive: bool = False,
+ timeout: Optional[float] = None,
+ ) -> Dict[str, Any]:
+ """Bridge resource deletion through normal session commit for mutable memories."""
+ if not resource_uri:
+ return {"status": "skipped", "reason": "empty_resource_uri"}
+ if not self._session_service:
+ return {"status": "skipped", "reason": "session_service_unavailable"}
+
+ deleted_at = datetime.now(timezone.utc).isoformat()
+ session_id = _RESOURCE_REASON_SESSION_ID
+ target_peer_id = _resource_reason_peer_id(ctx, resource_uri)
+ commit_result: Dict[str, Any] = {}
+ task_result: Optional[Dict[str, Any]] = None
+
+ async with self._reason_session_lock:
+ session = await self._session_service.get(
+ session_id,
+ ctx,
+ auto_create=True,
+ )
+ session.meta.memory_policy = _resource_deletion_memory_policy(target_peer_id)
+ message_spec: Dict[str, Any] = {
+ "role": "user",
+ "parts": [
+ TextPart(
+ text=self._build_resource_deletion_message(
+ resource_uri=resource_uri,
+ deleted_at=deleted_at,
+ memory_uris=memory_uris,
+ recursive=recursive,
+ )
+ )
+ ],
+ "created_at": deleted_at,
+ }
+ if target_peer_id:
+ message_spec["peer_id"] = target_peer_id
+ session.add_messages([message_spec])
+ commit_result = await self._session_service.commit_async(
+ session_id,
+ ctx,
+ keep_recent_count=0,
+ )
+
+ task_id = commit_result.get("task_id")
+ if task_id:
+ task_result = await self._wait_for_commit_task(
+ task_id=str(task_id),
+ ctx=ctx,
+ timeout=timeout,
+ )
+ return {
+ "status": "success",
+ "session_id": session_id,
+ "commit_task_id": task_id,
+ "archive_uri": commit_result.get("archive_uri"),
+ "commit_task": task_result,
+ }
+
@staticmethod
def _build_resource_addition_message(
*,
@@ -215,6 +299,28 @@ class ResourceMemoryLinkService:
f"User reason: {reason}"
)
+ @staticmethod
+ def _build_resource_deletion_message(
+ *,
+ resource_uri: str,
+ deleted_at: str,
+ memory_uris: Sequence[str],
+ recursive: bool,
+ ) -> str:
+ affected = "\n".join(f"- {uri}" for uri in dict.fromkeys(memory_uris))
+ if not affected:
+ affected = "- N/A"
+ recursive_text = "true" if recursive else "false"
+ return (
+ "## Resource Deletion\n"
+ f"Resource URI: {resource_uri}\n"
+ f"Deleted at: {deleted_at or 'N/A'}\n"
+ f"Recursive delete: {recursive_text}\n"
+ "Affected memory URIs:\n"
+ f"{affected}\n\n"
+ "Update existing mutable memories that mention or depend on this resource."
+ )
+
async def _wait_for_commit_task(
self,
*,
@@ -253,7 +359,7 @@ class ResourceMemoryLinkService:
resource_uri: str,
recursive: bool = False,
) -> Dict[str, Any]:
- """Remove references from user memories before deleting a resource."""
+ """Commit mutable memory updates and unlink stale references to a deleted resource."""
if context_type_for_uri(resource_uri) != "resource":
return {"status": "skipped", "reason": "not_resource"}
@@ -265,34 +371,42 @@ class ResourceMemoryLinkService:
if not matches:
return {"status": "no_references", "memory_uris": []}
+ memory_uris = self._memory_uris_from_matches(matches)
+ try:
+ commit_result = await self.on_resource_deleted(
+ ctx=ctx,
+ resource_uri=resource_uri,
+ memory_uris=memory_uris,
+ recursive=recursive,
+ )
+ except Exception as exc:
+ logger.warning("Resource deletion memory commit failed for %s: %s", resource_uri, exc)
+ commit_result = {"status": "failed", "error": str(exc)}
+
+ post_commit_matches = await self._find_referencing_memories(
+ ctx=ctx,
+ resource_uri=resource_uri,
+ recursive=recursive,
+ )
+
cleaned: List[str] = []
deleted: List[str] = []
errors: List[str] = []
- grouped = self._group_matches_by_memory(matches)
+ grouped = self._group_matches_by_memory(post_commit_matches)
for memory_uri, memory_matches in grouped.items():
first = memory_matches[0]
- reason = str(first.resource_ref.get("reason") or "")
try:
- cleanup_result = await self._cleanup_memory_reference(
+ cleanup_result = await self._unlink_memory_reference(
ctx=ctx,
memory_uri=memory_uri,
memory_file=first.memory_file,
resource_uri=resource_uri,
- reason=reason,
recursive=recursive,
)
cleaned.extend(cleanup_result.written_uris + cleanup_result.edited_uris)
deleted.extend(cleanup_result.deleted_uris)
if memory_uri in cleanup_result.deleted_uris:
continue
- if not cleanup_result.has_changes():
- await self._remove_resource_refs(
- memory_uri,
- resource_uri,
- ctx,
- recursive=recursive,
- )
- cleaned.append(memory_uri)
await self._assert_resource_unlinked(
memory_uri,
resource_uri,
@@ -312,19 +426,18 @@ class ResourceMemoryLinkService:
"status": "success",
"memory_uris": list(dict.fromkeys(cleaned)),
"deleted_memory_uris": list(dict.fromkeys(deleted)),
+ "memory_commit": commit_result,
}
- async def _cleanup_memory_reference(
+ async def _unlink_memory_reference(
self,
*,
ctx: RequestContext,
memory_uri: str,
memory_file: MemoryFile,
resource_uri: str,
- reason: str,
recursive: bool = False,
) -> MemoryUpdateResult:
- del reason
viking_fs = self._get_viking_fs()
current = memory_file
try:
@@ -335,7 +448,7 @@ class ResourceMemoryLinkService:
result.add_deleted(memory_uri)
return result
- changed = remove_resource_references_from_memory(
+ changed = unlink_resource_references_from_memory(
current,
resource_uri,
recursive=recursive,
@@ -346,67 +459,77 @@ class ResourceMemoryLinkService:
await viking_fs.write_file(memory_uri, MemoryFileUtils.write(current), ctx=ctx)
result.add_edited(memory_uri)
- if await self._delete_empty_cleanup_memory(memory_uri, ctx):
- self._mark_result_deleted(result, memory_uri)
return result
- async def _delete_empty_cleanup_memory(self, memory_uri: str, ctx: RequestContext) -> bool:
- """Delete memory files whose visible content was emptied by resource cleanup."""
- if context_type_for_uri(memory_uri) != "memory":
- return False
- viking_fs = self._get_viking_fs()
- try:
- raw = await viking_fs.read_file(memory_uri, ctx=ctx)
- except (NotFoundError, FileNotFoundError):
- return True
- mf = MemoryFileUtils.read(raw, uri=memory_uri)
- if (mf.content or "").strip():
- return False
- directory_uri = memory_uri.rsplit("/", 1)[0]
- await viking_fs.rm(memory_uri, recursive=False, ctx=ctx)
- await MemoryUpdater.refresh_schema_overview(
- viking_fs=viking_fs,
- directory_uri=directory_uri,
+ async def _find_referencing_memories(
+ self,
+ *,
+ ctx: RequestContext,
+ resource_uri: str,
+ recursive: bool,
+ ) -> List[_MemoryRefMatch]:
+ candidate_uris = await self._grep_candidate_memory_uris(
ctx=ctx,
+ resource_uri=resource_uri,
+ )
+ if candidate_uris is None:
+ logger.warning(
+ "Skipping resource memory reference scan for %s because grep is unavailable",
+ resource_uri,
+ )
+ return []
+ return await self._read_referencing_memory_matches(
+ candidate_uris,
+ ctx=ctx,
+ resource_uri=resource_uri,
+ recursive=recursive,
)
- logger.info("Deleted empty memory after resource cleanup: %s", memory_uri)
- return True
-
- @staticmethod
- def _mark_result_deleted(result: MemoryUpdateResult, uri: str) -> None:
- result.written_uris = [item for item in result.written_uris if item != uri]
- result.edited_uris = [item for item in result.edited_uris if item != uri]
- if uri not in result.deleted_uris:
- result.add_deleted(uri)
- async def _remove_resource_refs(
+ async def _grep_candidate_memory_uris(
self,
- memory_uri: str,
- resource_uri: str,
- ctx: RequestContext,
*,
- recursive: bool,
- ) -> None:
+ ctx: RequestContext,
+ resource_uri: str,
+ ) -> Optional[List[str]]:
+ """Use backend grep to avoid reading every memory file when supported."""
viking_fs = self._get_viking_fs()
- raw = await viking_fs.read_file(memory_uri, ctx=ctx)
- mf = MemoryFileUtils.read(raw, uri=memory_uri)
- refs = [
- ref
- for ref in self._coerce_resource_refs(mf.extra_fields.get("resource_refs"))
- if not self._resource_ref_matches(
- ref.get("resource_uri"),
- resource_uri,
- recursive=recursive,
- )
- ]
- if refs:
- mf.extra_fields["resource_refs"] = refs
- else:
- mf.extra_fields.pop("resource_refs", None)
- await viking_fs.write_file(memory_uri, MemoryFileUtils.write(mf), ctx=ctx)
+ if not hasattr(viking_fs, "grep"):
+ return None
- async def _find_referencing_memories(
+ search_needle = self._resource_uri_search_needle(resource_uri)
+ if not search_needle:
+ return []
+
+ candidate_uris: List[str] = []
+ for memory_root in _memory_roots_for_resource_refs(ctx, resource_uri):
+ try:
+ result = await viking_fs.grep(
+ memory_root,
+ pattern=re.escape(search_needle),
+ ctx=ctx,
+ node_limit=None,
+ level_limit=None,
+ )
+ except (NotFoundError, FileNotFoundError):
+ continue
+ except Exception as exc:
+ logger.debug(
+ "Resource memory grep failed for %s, skipping reference scan: %s",
+ memory_root,
+ exc,
+ )
+ return None
+
+ for match in result.get("matches", []):
+ uri = match.get("uri", "")
+ if self._is_memory_markdown_file(uri):
+ candidate_uris.append(uri)
+
+ return list(dict.fromkeys(candidate_uris))
+
+ async def _read_referencing_memory_matches(
self,
+ candidate_uris: Sequence[str],
*,
ctx: RequestContext,
resource_uri: str,
@@ -414,38 +537,30 @@ class ResourceMemoryLinkService:
) -> List[_MemoryRefMatch]:
viking_fs = self._get_viking_fs()
matches: List[_MemoryRefMatch] = []
- entries: List[Dict[str, Any]] = []
- for memory_root in _memory_roots_for_resource_refs(ctx, resource_uri):
+ search_needle = self._resource_uri_search_needle(resource_uri)
+ for uri in candidate_uris:
try:
- entries.extend(
- await viking_fs.tree(
- memory_root,
- ctx=ctx,
- node_limit=1000000,
- level_limit=None,
- )
- )
+ raw = await viking_fs.read_file(uri, ctx=ctx)
+ raw_text = raw if isinstance(raw, str) else str(raw or "")
except Exception:
continue
-
- for entry in entries:
- uri = entry.get("uri", "")
- rel_path = entry.get("rel_path", "")
- if entry.get("isDir") or not uri.endswith(".md"):
- continue
- if rel_path.endswith("/.abstract.md") or rel_path.endswith("/.overview.md"):
+ if search_needle and search_needle not in raw_text:
continue
+
try:
- raw = await viking_fs.read_file(uri, ctx=ctx)
- mf = MemoryFileUtils.read(raw, uri=uri)
+ mf = MemoryFileUtils.read(raw_text, uri=uri)
except Exception:
continue
+
+ matched = False
for ref in self._coerce_resource_refs(mf.extra_fields.get("resource_refs")):
if self._resource_ref_matches(ref.get("resource_uri"), resource_uri, recursive):
matches.append(_MemoryRefMatch(uri, mf, ref))
- if not any(
- match.memory_uri == uri for match in matches
- ) and content_references_resource(
+ matched = True
+ if matched:
+ continue
+
+ if content_references_resource(
mf.content,
resource_uri,
recursive=recursive,
@@ -470,6 +585,19 @@ class ResourceMemoryLinkService:
)
return matches
+ @staticmethod
+ def _resource_uri_search_needle(resource_uri: str) -> str:
+ return (resource_uri or "").strip().rstrip("/")
+
+ @staticmethod
+ def _is_memory_markdown_file(uri: str) -> bool:
+ return (
+ isinstance(uri, str)
+ and uri.endswith(".md")
+ and not uri.endswith("/.abstract.md")
+ and not uri.endswith("/.overview.md")
+ )
+
async def _read_resource_directory_abstract(
self,
resource_uri: str,
@@ -558,6 +686,10 @@ class ResourceMemoryLinkService:
grouped.setdefault(match.memory_uri, []).append(match)
return grouped
+ @staticmethod
+ def _memory_uris_from_matches(matches: Sequence[_MemoryRefMatch]) -> List[str]:
+ return list(dict.fromkeys(match.memory_uri for match in matches))
+
@staticmethod
def _resource_ref_matches(
ref_uri: Any,
diff --git a/openviking/session/memory/memory_updater.py b/openviking/session/memory/memory_updater.py
index b3de674d0..f4ede2412 100644
--- a/openviking/session/memory/memory_updater.py
+++ b/openviking/session/memory/memory_updater.py
@@ -1228,12 +1228,6 @@ class MemoryUpdater:
# Extract filename from path
filename = file_path.split("/")[-1]
metadata = mf.to_metadata()
- self._fill_overview_fallback_fields(
- memory_type=memory_type,
- directory=directory,
- filename=filename,
- metadata=metadata,
- )
items.append(
{
@@ -1249,14 +1243,17 @@ class MemoryUpdater:
logger.debug(f"No valid memory files parsed in {directory}")
return
+ overview_context = {
+ "memory_type": memory_type,
+ "directory_name": directory.rstrip("/").split("/")[-1],
+ "items": items,
+ }
+
# Render the template
try:
rendered = render_template(
schema.overview_template,
- {
- "memory_type": memory_type,
- "items": items,
- },
+ overview_context,
extract_context=extract_context,
)
except Exception as e:
@@ -1269,20 +1266,3 @@ class MemoryUpdater:
await viking_fs.write_file(overview_path, rendered, ctx=ctx)
except Exception as e:
tracer.error(f"Failed to write overview {overview_path}: {e}")
-
- @staticmethod
- def _fill_overview_fallback_fields(
- *,
- memory_type: str,
- directory: str,
- filename: str,
- metadata: Dict[str, Any],
- ) -> None:
- stem = filename.removesuffix(".md")
- parent_name = directory.rstrip("/").split("/")[-1]
- if memory_type == "entities":
- metadata.setdefault("category", parent_name)
- metadata.setdefault("name", stem)
- elif memory_type == "preferences":
- metadata.setdefault("user", parent_name)
- metadata.setdefault("topic", stem)
diff --git a/openviking/session/memory/session_extract_context_provider.py b/openviking/session/memory/session_extract_context_provider.py
index 5dbdcb18d..d6d35d28b 100644
--- a/openviking/session/memory/session_extract_context_provider.py
+++ b/openviking/session/memory/session_extract_context_provider.py
@@ -186,18 +186,25 @@ class SessionExtractContextProvider(ExtractContextProvider):
def instruction(self) -> str:
output_language = self._output_language
+ contains_resource_uri = self._conversation_contains_resource_uri()
resource_uri_handling = (
"""
## Resource URI Handling
- If the conversation contains a resource URI (`viking://resources/...`, `viking://user/{user_id}/resources/...`, or `viking://user/{user_id}/peers/{peer_id}/resources/...`) and the user says a durable fact, judgment, preference, or event about it, extract that memory into the appropriate normal memory type such as entities, events, or preferences.
-- Preserve resource references as markdown links in visible memory content when useful. Example: user said "用户保存了越前龙马照片 viking://resources/images/ryoma" -> write "用户保存了[越前龙马照片](viking://resources/images/ryoma)".
+- Preserve resource references as markdown links in visible memory content when useful. Example: user said "The user saved a Ryoma Echizen photo viking://resources/images/ryoma" -> write "The user saved a [Ryoma Echizen photo](viking://resources/images/ryoma)".
- For `## Resource Addition` blocks, use `User reason` as the user's intent and `Resource abstract` only as optional context. Do not copy raw fields such as `Resource URI`, `Added at`, `Resource abstract`, or `User reason` into visible memory content.
-- Use descriptive link text such as `[越前龙马照片](viking://resources/...)`; avoid visible wording like `资源URI为` or `Resource URI`.
+- For `## Resource Deletion` blocks, update existing mutable memories that mention or depend on the deleted resource. Do not create a new event solely for this maintenance action.
+- Use descriptive link text such as `[Ryoma Echizen photo](viking://resources/...)`; avoid visible wording like `resource URI is` or `Resource URI`.
- If the user already wrote a markdown link to a resource URI, keep the same resource link intent.
- Do NOT claim you inspected, summarized, OCRed, or opened the resource file unless the conversation explicitly provides that fact.
"""
- if self._conversation_contains_resource_uri()
+ if contains_resource_uri
+ else ""
+ )
+ resource_deletion_read_source = (
+ ", or listed under the system-generated `## Resource Deletion` block's `Affected memory URIs`"
+ if contains_resource_uri
else ""
)
goal = f"""You are a memory extraction agent. Your task is to analyze conversations and update memories.
@@ -210,7 +217,7 @@ class SessionExtractContextProvider(ExtractContextProvider):
## Critical
- ONLY read and search tools are available - DO NOT use write tool
- Before editing ANY existing memory file, you MUST first read its complete content
-- ONLY read URIs that are explicitly listed in ls tool results or returned by previous tool calls
+- ONLY read URIs that are explicitly listed in ls/search tool results, returned by previous tool calls{resource_deletion_read_source}
## Target Output Language
All memory content MUST be written in {output_language}.
diff --git a/openviking/session/memory/utils/resource_refs.py b/openviking/session/memory/utils/resource_refs.py
index d80e0d8ee..02f441d2e 100644
--- a/openviking/session/memory/utils/resource_refs.py
+++ b/openviking/session/memory/utils/resource_refs.py
@@ -6,7 +6,7 @@ from __future__ import annotations
import re
from datetime import datetime, timezone
-from typing import Any, Dict, Iterable, List, Optional, Sequence
+from typing import Any, Dict, List, Optional, Sequence
from openviking.session.memory.dataclass import MemoryFile
@@ -32,13 +32,6 @@ _INLINE_CODE_RE = re.compile(r"`[^`\n]+`")
_TRAILING_URI_PUNCTUATION = ".,;:!?,。;:!?、)】》"
_SENTENCE_BOUNDARIES = "。!?.!?\n"
_MAX_LINKIFIED_SENTENCE_CHARS = 160
-_RESOURCE_CLEANUP_ARTIFACT_LINE_RE = re.compile(
- r"(?m)^(?:None ChatLog:|Original reason:\s*|Memory URI:\s*viking://user/[^\n]*)\n?"
-)
-_RESOURCE_URI_MARKER_RE = re.compile(
- r"[,,;;::\s]*(?:资源\s*URI\s*为|资源\s*URI|Resource\s+URI)\s*[::为]?\s*$",
- re.IGNORECASE,
-)
def sync_memory_resource_refs(
@@ -109,17 +102,17 @@ def extract_resource_uris(content: str) -> List[str]:
return list(dict.fromkeys(uris))
-def remove_resource_references_from_memory(
+def unlink_resource_references_from_memory(
mf: MemoryFile,
resource_uri: str,
*,
recursive: bool = False,
) -> bool:
- """Remove visible references and MEMORY_FIELDS.resource_refs for one resource."""
+ """Remove stale resource link targets while preserving visible memory text."""
before_content = mf.content
before_refs = _coerce_resource_refs(mf.extra_fields.get("resource_refs"))
- mf.content = remove_resource_references_from_content(
+ mf.content = unlink_resource_references_from_content(
mf.content,
resource_uri,
recursive=recursive,
@@ -137,24 +130,17 @@ def remove_resource_references_from_memory(
return before_content != mf.content or before_refs != refs
-def remove_resource_references_from_content(
+def unlink_resource_references_from_content(
content: str,
resource_uri: str,
*,
recursive: bool = False,
) -> str:
- """Remove sentences/list lines that contain matching resource URI references."""
+ """Turn matching resource links into plain text and remove bare resource URIs."""
text = content or ""
- spans = _matching_resource_reference_spans(text, resource_uri, recursive=recursive)
- if not spans:
- return text
-
- sentence_spans = _merge_spans(
- _expand_to_sentence_span(text, start, end) for start, end in spans
- )
- for start, end in reversed(sentence_spans):
- text = text[:start] + text[end:]
- return _normalize_removed_reference_text(text)
+ text = _unlink_matching_markdown_resource_links(text, resource_uri, recursive=recursive)
+ text = _remove_matching_bare_resource_uris(text, resource_uri, recursive=recursive)
+ return _normalize_unlinked_reference_text(text)
def resource_ref_matches(
@@ -199,6 +185,39 @@ def _extract_markdown_resource_refs(
return refs, link_spans
+def _unlink_matching_markdown_resource_links(
+ content: str,
+ resource_uri: str,
+ *,
+ recursive: bool,
+) -> str:
+ def replacement(match: re.Match[str]) -> str:
+ label = match.group(1).strip()
+ linked_uri = match.group(2)
+ if resource_ref_matches(linked_uri, resource_uri, recursive=recursive):
+ return label
+ return match.group(0)
+
+ return _MARKDOWN_RESOURCE_LINK_RE.sub(replacement, content or "")
+
+
+def _remove_matching_bare_resource_uris(
+ content: str,
+ resource_uri: str,
+ *,
+ recursive: bool,
+) -> str:
+ text = content or ""
+ for match in reversed(list(_RESOURCE_URI_RE.finditer(text))):
+ matched_uri = _trim_resource_uri(match.group(0))
+ if not resource_ref_matches(matched_uri, resource_uri, recursive=recursive):
+ continue
+ start = match.start()
+ end = start + len(matched_uri)
+ text = text[:start] + text[end:]
+ return text
+
+
def _linkify_bare_resource_uris(
content: str,
protected_spans: Sequence[tuple[int, int]],
@@ -227,16 +246,6 @@ def _linkify_bare_resource_uris(
anchor_start = sentence_start
anchor_end = sentence_end
anchor = updated[anchor_start:anchor_end]
- marker_span = _resource_uri_marker_span(anchor)
- if marker_span:
- label_span = _resource_clause_span_before_marker(
- updated,
- sentence_start,
- sentence_start + marker_span[0],
- )
- if label_span:
- anchor_start, anchor_end = label_span
- anchor = updated[anchor_start:anchor_end]
if contains_resource_uri(anchor) or "](" in anchor:
continue
refs[-1]["match_text"] = anchor
@@ -347,96 +356,9 @@ def _trim_resource_uri(resource_uri: str) -> str:
return (resource_uri or "").rstrip(_TRAILING_URI_PUNCTUATION)
-def _matching_resource_reference_spans(
- content: str,
- resource_uri: str,
- *,
- recursive: bool,
-) -> List[tuple[int, int]]:
- spans: List[tuple[int, int]] = []
- markdown_spans: List[tuple[int, int]] = []
- for match in _MARKDOWN_RESOURCE_LINK_RE.finditer(content or ""):
- markdown_spans.append((match.start(), match.end()))
- if resource_ref_matches(match.group(2), resource_uri, recursive=recursive):
- spans.append((match.start(), match.end()))
-
- for match in _RESOURCE_URI_RE.finditer(content or ""):
- resource_end = match.start() + len(_trim_resource_uri(match.group(0)))
- if _overlaps_spans(match.start(), resource_end, markdown_spans):
- continue
- if resource_ref_matches(match.group(0), resource_uri, recursive=recursive):
- spans.append((match.start(), resource_end))
- return spans
-
-
-def _resource_uri_marker_span(anchor: str) -> Optional[tuple[int, int]]:
- match = _RESOURCE_URI_MARKER_RE.search(anchor)
- if not match:
- return None
- return match.start(), match.end()
-
-
-def _resource_clause_span_before_marker(
- content: str,
- sentence_start: int,
- marker_start: int,
-) -> Optional[tuple[int, int]]:
- prefix = content[sentence_start:marker_start].rstrip(",,;;:: ")
- if not prefix:
- return None
-
- pieces = list(re.finditer(r"[^,,;;。.!??]+$", prefix))
- if not pieces:
- return None
- label_start = sentence_start + pieces[-1].start()
- label_end = sentence_start + pieces[-1].end()
- if _valid_resource_clause(content[label_start:label_end]):
- return label_start, label_end
- return None
-
-
-def _valid_resource_clause(clause: str) -> bool:
- clause = clause.strip()
- return bool(clause) and len(clause) <= 120 and "\n" not in clause and "](" not in clause
-
-
-def _expand_to_sentence_span(content: str, start: int, end: int) -> tuple[int, int]:
- span_start = start
- for idx in range(start - 1, -1, -1):
- if content[idx] in _SENTENCE_BOUNDARIES:
- span_start = idx + 1
- break
- else:
- span_start = 0
-
- span_end = end
- for idx in range(end, len(content)):
- if content[idx] in _SENTENCE_BOUNDARIES:
- span_end = idx + 1
- break
- else:
- span_end = len(content)
-
- while span_start < span_end and content[span_start].isspace():
- span_start += 1
- while span_end < len(content) and content[span_end].isspace():
- span_end += 1
- return span_start, span_end
-
-
-def _merge_spans(spans: Iterable[tuple[int, int]]) -> List[tuple[int, int]]:
- merged: List[tuple[int, int]] = []
- for start, end in sorted(spans):
- if not merged or start > merged[-1][1]:
- merged.append((start, end))
- else:
- merged[-1] = (merged[-1][0], max(merged[-1][1], end))
- return merged
-
-
-def _normalize_removed_reference_text(content: str) -> str:
- content = _RESOURCE_CLEANUP_ARTIFACT_LINE_RE.sub("", content)
+def _normalize_unlinked_reference_text(content: str) -> str:
text = re.sub(r"[ \t]+([,。;:!?,.!?;:])", r"\1", content)
+ text = re.sub(r"[ \t]{2,}", " ", text)
text = re.sub(r"\n{3,}", "\n\n", text)
return text.strip()
diff --git a/tests/service/test_resource_memory_link_service.py b/tests/service/test_resource_memory_link_service.py
index 45b12e32d..8b6a204e8 100644
--- a/tests/service/test_resource_memory_link_service.py
+++ b/tests/service/test_resource_memory_link_service.py
@@ -2,8 +2,8 @@
# SPDX-License-Identifier: AGPL-3.0
"""Tests for resource-memory linking service."""
+import re
from types import SimpleNamespace
-from unittest.mock import AsyncMock
import pytest
@@ -13,7 +13,6 @@ from openviking.service.resource_memory_link_service import (
ResourceMemoryLinkService,
)
from openviking.session.memory.dataclass import MemoryFile
-from openviking.session.memory.memory_updater import MemoryUpdateResult
from openviking.session.memory.utils.memory_file_utils import MemoryFileUtils
from openviking_cli.session.user_id import UserIdentifier
@@ -22,8 +21,11 @@ class _FakeVikingFS:
def __init__(self, store):
self.store = store
self.rm_calls = []
+ self.read_calls = []
+ self.tree_calls = []
async def read_file(self, uri, ctx=None):
+ self.read_calls.append(uri)
return self.store[uri]
async def write_file(self, uri, content, ctx=None):
@@ -34,6 +36,13 @@ class _FakeVikingFS:
self.store.pop(uri, None)
async def tree(self, uri, ctx=None, node_limit=None, level_limit=None):
+ self.tree_calls.append(
+ {
+ "uri": uri,
+ "node_limit": node_limit,
+ "level_limit": level_limit,
+ }
+ )
prefix = uri.rstrip("/") + "/"
return [
{
@@ -45,6 +54,80 @@ class _FakeVikingFS:
if item_uri.startswith(prefix)
]
+ async def grep(
+ self,
+ uri,
+ pattern,
+ exclude_uri=None,
+ case_insensitive=False,
+ node_limit=None,
+ level_limit=None,
+ ctx=None,
+ ):
+ del exclude_uri, case_insensitive, level_limit, ctx
+ prefix = uri.rstrip("/") + "/"
+ matches = [
+ {
+ "uri": item_uri,
+ "line": 1,
+ "content": content,
+ }
+ for item_uri, content in self.store.items()
+ if item_uri.startswith(prefix) and re.search(pattern, content)
+ ]
+ if node_limit is not None:
+ matches = matches[:node_limit]
+ return {
+ "matches": matches,
+ "count": len(matches),
+ "match_count": len(matches),
+ "files_scanned": len(self.store),
+ }
+
+
+class _FakeGrepVikingFS(_FakeVikingFS):
+ def __init__(self, store, grep_uris):
+ super().__init__(store)
+ self.grep_uris = grep_uris
+ self.grep_calls = []
+
+ async def grep(
+ self,
+ uri,
+ pattern,
+ exclude_uri=None,
+ case_insensitive=False,
+ node_limit=None,
+ level_limit=None,
+ ctx=None,
+ ):
+ self.grep_calls.append(
+ {
+ "uri": uri,
+ "pattern": pattern,
+ "exclude_uri": exclude_uri,
+ "case_insensitive": case_insensitive,
+ "node_limit": node_limit,
+ "level_limit": level_limit,
+ }
+ )
+ return {
+ "matches": [
+ {
+ "uri": match_uri,
+ "line": 1,
+ "content": self.store.get(match_uri, ""),
+ }
+ for match_uri in self.grep_uris
+ ],
+ "count": len(self.grep_uris),
+ "match_count": len(self.grep_uris),
+ "files_scanned": len(self.store),
+ }
+
+ async def tree(self, uri, ctx=None, node_limit=None, level_limit=None):
+ raise AssertionError("grep path should not fall back to tree")
+
class _ReadFailVikingFS:
async def read_file(self, uri, ctx=None):
@@ -266,6 +349,37 @@ async def test_on_resource_added_routes_peer_resource_uri_to_peer(request_contex
assert session_service.session.messages[0]["peer_id"] == "web-visitor-alice"
+async def test_on_resource_deleted_bridges_through_fixed_session(request_context):
+ resource_uri = "viking://resources/images/2026/06/11/yueqian_jpeg"
+ memory_uri = "viking://user/alice/memories/entities/photos.md"
+ session_service = _FakeSessionService()
+ service = ResourceMemoryLinkService(
+ viking_fs=_FakeVikingFS({}),
+ session_service=session_service,
+ )
+
+ result = await service.on_resource_deleted(
+ ctx=request_context,
+ resource_uri=resource_uri,
+ memory_uris=[memory_uri],
+ recursive=True,
+ )
+
+ assert result["status"] == "success"
+ assert result["session_id"] == _RESOURCE_REASON_SESSION_ID
+ assert session_service.session.meta.memory_policy == {
+ "self": {"enabled": True},
+ "peer": {"enabled": False},
+ "memory_types": ["entities", "preferences"],
+ }
+ message_text = session_service.session.messages[0]["parts"][0].text
+ assert "## Resource Deletion" in message_text
+ assert resource_uri in message_text
+ assert memory_uri in message_text
+ assert "Do not create a new event" in message_text
+
+
@pytest.mark.asyncio
async def test_read_resource_directory_abstract_uses_parent_abstract(request_context):
service = ResourceMemoryLinkService(
@@ -341,6 +455,59 @@ async def test_find_referencing_memories_uses_memory_refs(request_context):
assert matches[0].resource_ref["resource_uri"] == resource_uri
+async def test_find_referencing_memories_uses_grep_candidates_without_tree_scan(request_context):
+ memory_uri = "viking://user/alice/memories/entities/wang.md"
+ unrelated_uri = "viking://user/alice/memories/entities/unrelated.md"
+ overview_uri = "viking://user/alice/memories/entities/.overview.md"
+ resource_uri = "viking://resources/docs/id_card.pdf"
+ raw = MemoryFileUtils.write(
+ MemoryFile(
+ uri=memory_uri,
+ content="王大锤资料。",
+ extra_fields={
+ "resource_refs": [
+ {
+ "resource_uri": resource_uri,
+ "reason": "这是王大锤的身份证",
+ }
+ ]
+ },
+ )
+ )
+ store = {
+ memory_uri: raw,
+ unrelated_uri: "不会命中的普通记忆",
+ overview_uri: f"- [王大锤]({memory_uri})",
+ }
+ viking_fs = _FakeGrepVikingFS(
+ store,
+ grep_uris=[memory_uri, memory_uri, overview_uri],
+ )
+ service = ResourceMemoryLinkService(viking_fs=viking_fs)
+
+ matches = await service._find_referencing_memories(
+ ctx=request_context,
+ resource_uri=resource_uri,
+ recursive=False,
+ )
+
+ assert len(matches) == 1
+ assert matches[0].memory_uri == memory_uri
+ assert viking_fs.grep_calls == [
+ {
+ "uri": "viking://user/alice/memories",
+ "pattern": re.escape(resource_uri),
+ "exclude_uri": None,
+ "case_insensitive": False,
+ "node_limit": None,
+ "level_limit": None,
+ }
+ ]
+ assert viking_fs.read_calls == [memory_uri]
+ assert viking_fs.tree_calls == []
+
+
@pytest.mark.asyncio
async def test_find_referencing_memories_scans_actor_peer_memory(request_context):
peer_ctx = RequestContext(
@@ -377,7 +544,7 @@ async def test_find_referencing_memories_scans_actor_peer_memory(request_context
@pytest.mark.asyncio
-async def test_before_resource_delete_removes_refs_when_cleanup_has_no_changes(request_context):
+async def test_before_resource_delete_commits_then_unlinks_stale_refs(request_context):
memory_uri = "viking://user/alice/memories/entities/wang.md"
resource_uri = "viking://resources/id_card.pdf"
raw = (
@@ -393,8 +560,11 @@ async def test_before_resource_delete_removes_refs_when_cleanup_has_no_changes(r
"}\n"
"-->"
)
- service = ResourceMemoryLinkService(viking_fs=_FakeVikingFS({memory_uri: raw}))
- service._cleanup_memory_reference = AsyncMock(return_value=MemoryUpdateResult())
+ session_service = _FakeSessionService()
+ service = ResourceMemoryLinkService(
+ viking_fs=_FakeVikingFS({memory_uri: raw}),
+ session_service=session_service,
+ )
result = await service.before_resource_delete(
ctx=request_context,
@@ -402,12 +572,20 @@ async def test_before_resource_delete_removes_refs_when_cleanup_has_no_changes(r
)
assert result["status"] == "success"
+ assert result["memory_commit"]["status"] == "success"
+ assert session_service.committed == [
+ {
+ "ctx": request_context,
+ "session_id": _RESOURCE_REASON_SESSION_ID,
+ "keep_recent_count": 0,
+ }
+ ]
mf = MemoryFileUtils.read(service._get_viking_fs().store[memory_uri], uri=memory_uri)
assert "resource_refs" not in mf.extra_fields
@pytest.mark.asyncio
-async def test_cleanup_memory_reference_does_not_introduce_schema_metadata(request_context):
+async def test_unlink_memory_reference_keeps_visible_text_and_no_schema_metadata(request_context):
memory_uri = "viking://user/ryoma/memories/entities/动漫角色/不二周助-write-test3.md"
resource_uri = "viking://resources/images/2026/06/10/不二周助_jpeg"
original_raw = MemoryFileUtils.write(
@@ -427,27 +605,25 @@ async def test_cleanup_memory_reference_does_not_introduce_schema_metadata(reque
store = {memory_uri: original_raw}
service = ResourceMemoryLinkService(viking_fs=_FakeVikingFS(store))
- result = await service._cleanup_memory_reference(
+ result = await service._unlink_memory_reference(
ctx=request_context,
memory_uri=memory_uri,
memory_file=MemoryFileUtils.read(original_raw, uri=memory_uri),
resource_uri=resource_uri,
- reason="",
)
assert result.edited_uris == [memory_uri]
mf = MemoryFileUtils.read(store[memory_uri], uri=memory_uri)
- assert mf.content == "今天是清明节。"
+ assert mf.content == "今天是清明节。用户保存了一张不二周助的照片"
assert mf.extra_fields == {}
assert mf.memory_type is None
@pytest.mark.asyncio
-async def test_cleanup_memory_reference_deletes_empty_memory_shell(
+async def test_unlink_memory_reference_does_not_delete_event_memory(
request_context,
- monkeypatch,
):
- memory_uri = "viking://user/ryoma/memories/entities/动漫角色/越前龙马.md"
+ memory_uri = "viking://user/ryoma/memories/events/2026/06/11/越前龙马.md"
resource_uri = "viking://resources/images/2026/06/11/yueqian_jpeg"
original_raw = MemoryFileUtils.write(
MemoryFile(
@@ -463,31 +639,25 @@ async def test_cleanup_memory_reference_deletes_empty_memory_shell(
)
store = {memory_uri: original_raw}
service = ResourceMemoryLinkService(viking_fs=_FakeVikingFS(store))
- refresh_overview = AsyncMock()
- monkeypatch.setattr(
- "openviking.service.resource_memory_link_service.MemoryUpdater.refresh_schema_overview",
- refresh_overview,
- )
- result = await service._cleanup_memory_reference(
+ result = await service._unlink_memory_reference(
ctx=request_context,
memory_uri=memory_uri,
memory_file=MemoryFileUtils.read(original_raw, uri=memory_uri),
resource_uri=resource_uri,
- reason="这是越前龙马的照片",
)
- assert memory_uri not in store
- assert service._get_viking_fs().rm_calls == [(memory_uri, False)]
- assert result.edited_uris == []
- assert result.deleted_uris == [memory_uri]
- refresh_overview.assert_awaited_once()
+ assert memory_uri in store
+ assert service._get_viking_fs().rm_calls == []
+ assert result.edited_uris == [memory_uri]
+ assert result.deleted_uris == []
+ mf = MemoryFileUtils.read(store[memory_uri], uri=memory_uri)
+ assert mf.content == "用户保存了一张越前龙马的照片"
@pytest.mark.asyncio
async def test_before_resource_delete_cleans_visible_uri_without_resource_refs(
request_context,
- monkeypatch,
):
memory_uri = "viking://user/alice/memories/events/2026/06/11/yueqian.md"
resource_uri = "viking://resources/images/2026/06/12/yueqian_jpeg"
@@ -502,11 +672,6 @@ async def test_before_resource_delete_cleans_visible_uri_without_resource_refs(
)
store = {memory_uri: raw}
service = ResourceMemoryLinkService(viking_fs=_FakeVikingFS(store))
- refresh_overview = AsyncMock()
- monkeypatch.setattr(
- "openviking.service.resource_memory_link_service.MemoryUpdater.refresh_schema_overview",
- refresh_overview,
- )
result = await service.before_resource_delete(
ctx=request_context,
@@ -516,7 +681,7 @@ async def test_before_resource_delete_cleans_visible_uri_without_resource_refs(
assert result["status"] == "success"
assert result["memory_uris"] == [memory_uri]
mf = MemoryFileUtils.read(store[memory_uri], uri=memory_uri)
- assert mf.content == "今天是清明节。"
+ assert mf.content == "今天是清明节。\n用户昨晚查看了越前龙马照片,之后可参考该资源。"
assert "resource_refs" not in mf.extra_fields
@@ -553,50 +718,12 @@ async def test_before_resource_delete_exact_keeps_child_resource_refs(
assert result["status"] == "success"
mf = MemoryFileUtils.read(store[memory_uri], uri=memory_uri)
assert f"[相册资源]({resource_uri})" not in mf.content
+ assert "用户保存了相册资源。" in mf.content
assert f"[相册里的子图]({child_uri})" in mf.content
refs = mf.extra_fields["resource_refs"]
assert refs == [{"resource_uri": child_uri, "source": "content.write"}]
-async def test_before_resource_delete_deletes_previous_failed_cleanup_artifact(
- request_context,
- monkeypatch,
-):
- memory_uri = "viking://user/alice/memories/events/2026/06/11/yueqian.md"
- resource_uri = "viking://resources/images/2026/06/12/yueqian_jpeg"
- raw = MemoryFileUtils.write(
- MemoryFile(
- uri=memory_uri,
- content=(
- f"Summary: 用户查看了[越前龙马照片]({resource_uri})。\n"
- "None ChatLog:\n"
- f"[[user]: Deleted resource URI:]({resource_uri})\n"
- "Original reason: \n"
- f"Memory URI: {memory_uri}"
- ),
- extra_fields={"memory_type": "events"},
- )
- )
- store = {memory_uri: raw}
- service = ResourceMemoryLinkService(viking_fs=_FakeVikingFS(store))
- refresh_overview = AsyncMock()
- monkeypatch.setattr(
- "openviking.service.resource_memory_link_service.MemoryUpdater.refresh_schema_overview",
- refresh_overview,
- )
-
- result = await service.before_resource_delete(
- ctx=request_context,
- resource_uri=resource_uri,
- )
-
- assert result["status"] == "success"
- assert result["deleted_memory_uris"] == [memory_uri]
- assert memory_uri not in store
- refresh_overview.assert_awaited_once()
-
-
@pytest.mark.asyncio
async def test_assert_resource_unlinked_propagates_non_not_found_errors(request_context):
service = ResourceMemoryLinkService(viking_fs=_ReadFailVikingFS())
diff --git a/tests/session/memory/test_memory_react_system_prompt.py b/tests/session/memory/test_memory_react_system_prompt.py
index 26a1a6ab9..32b2c3c43 100644
--- a/tests/session/memory/test_memory_react_system_prompt.py
+++ b/tests/session/memory/test_memory_react_system_prompt.py
@@ -26,7 +26,7 @@ class TestProviderInstruction:
in instruction
)
assert (
- "ONLY read URIs that are explicitly listed in ls tool results or returned by previous tool calls"
+ "ONLY read URIs that are explicitly listed in ls/search tool results, returned by previous tool calls"
in instruction
)
@@ -58,6 +58,7 @@ class TestProviderInstruction:
instruction = provider.instruction()
assert "Resource URI Handling" not in instruction
+ assert "Affected memory URIs" not in instruction
def test_instruction_includes_resource_uri_handling_for_user_scoped_resource_uri(self):
provider = SessionExtractContextProvider(
@@ -80,6 +81,9 @@ class TestProviderInstruction:
assert "Resource URI Handling" in instruction
assert "viking://user/{user_id}/resources/..." in instruction
assert "viking://user/{user_id}/peers/{peer_id}/resources/..." in instruction
+ assert (
+ "system-generated `## Resource Deletion` block's `Affected memory URIs`" in instruction
+ )
class TestSkillToolCallExposure:
diff --git a/tests/session/memory/test_memory_updater.py b/tests/session/memory/test_memory_updater.py
index 1a548c2c7..5f6d11486 100644
--- a/tests/session/memory/test_memory_updater.py
+++ b/tests/session/memory/test_memory_updater.py
@@ -238,6 +238,124 @@ class TestMemoryUpdater:
assert viking_fs.rm_calls == []
+ @pytest.mark.asyncio
+ async def test_generate_events_overview_without_extract_context_uses_summary_or_filename(self):
+ schema = MemoryTypeSchema(
+ memory_type="events",
+ description="event memory",
+ directory="viking://user/{{ user_space }}/memories/events",
+ filename_template="{{ event_name }}.md",
+ fields=[],
+ overview_template=(
+ "# Events Overview\n"
+ "{% for item in items %}\n"
+ "- [{{ item.file_content.summary|default(item.file_name, true) }}](./{{ item.file_name }})\n"
+ "{% endfor %}"
+ ),
+ )
+ registry = MagicMock()
+ registry.get.return_value = schema
+
+ directory = "viking://user/alice/memories/events/2026/06/16"
+ event_uri = f"{directory}/kept_event.md"
+ plain_event_uri = f"{directory}/plain_event.md"
+ overview_uri = f"{directory}/.overview.md"
+
+ class FakeVikingFS:
+ def __init__(self):
+ self.store = {
+ event_uri: MemoryFileUtils.write(
+ MemoryFile(
+ uri=event_uri,
+ content="Summary: kept event",
+ memory_type="events",
+ extra_fields={
+ "event_name": "kept_event",
+ "summary": "kept event",
+ "ranges": "0",
+ },
+ )
+ ),
+ plain_event_uri: "Plain event first sentence. More detail on the same line.",
+ overview_uri: (
+ "# Events Overview\n"
+ "**Date:** 2026/06/16\n"
+ "- [deleted event](./deleted_event.md)\n"
+ ),
+ }
+
+ async def ls(self, uri, show_all_hidden=False, ctx=None):
+ return [
+ {"name": "kept_event.md", "isDir": False},
+ {"name": "plain_event.md", "isDir": False},
+ {"name": ".overview.md", "isDir": False},
+ ]
+
+ async def read_file(self, uri, ctx=None):
+ return self.store[uri]
+
+ async def write_file(self, uri, content, ctx=None):
+ self.store[uri] = content
+
+ viking_fs = FakeVikingFS()
+ updater = MemoryUpdater(registry=registry)
+ updater._get_viking_fs = MagicMock(return_value=viking_fs)
+ ctx = RequestContext(user=UserIdentifier("acme", "alice"), role=Role.USER)
+
+ await updater.generate_overview("events", directory, ctx, extract_context=None)
+
+ assert "**Date:**" not in viking_fs.store[overview_uri]
+ assert "- [kept event](./kept_event.md)" in viking_fs.store[overview_uri]
+ assert "- [plain_event.md](./plain_event.md)" in viking_fs.store[overview_uri]
+ assert "deleted_event.md" not in viking_fs.store[overview_uri]
+
+ @pytest.mark.asyncio
+ async def test_generate_overview_template_fallbacks_for_preferences_and_entities(self):
+ registry = MemoryTypeRegistry(load_schemas=False)
+ registry.load_from_yaml("openviking/prompts/templates/memory/entities.yaml")
+ registry.load_from_yaml("openviking/prompts/templates/memory/preferences.yaml")
+
+ entity_dir = "viking://user/alice/memories/entities/动漫角色"
+ entity_uri = f"{entity_dir}/越前龙马.md"
+ entity_overview_uri = f"{entity_dir}/.overview.md"
+ preference_dir = "viking://user/alice/memories/preferences/alice"
+ preference_uri = f"{preference_dir}/workflow.md"
+ preference_overview_uri = f"{preference_dir}/.overview.md"
+
+ class FakeVikingFS:
+ def __init__(self):
+ self.store = {
+ entity_uri: "A tennis character.",
+ preference_uri: "Prefers concise updates.",
+ }
+
+ async def ls(self, uri, show_all_hidden=False, ctx=None):
+ if uri == entity_dir:
+ return [{"name": "越前龙马.md", "isDir": False}]
+ if uri == preference_dir:
+ return [{"name": "workflow.md", "isDir": False}]
+ return []
+
+ async def read_file(self, uri, ctx=None):
+ return self.store[uri]
+
+ async def write_file(self, uri, content, ctx=None):
+ self.store[uri] = content
+
+ viking_fs = FakeVikingFS()
+ updater = MemoryUpdater(registry=registry)
+ updater._get_viking_fs = MagicMock(return_value=viking_fs)
+ ctx = RequestContext(user=UserIdentifier("acme", "alice"), role=Role.USER)
+
+ await updater.generate_overview("entities", entity_dir, ctx, extract_context=None)
+ await updater.generate_overview("preferences", preference_dir, ctx, extract_context=None)
+
+ assert "**Category:** 动漫角色" in viking_fs.store[entity_overview_uri]
+ assert "- [越前龙马.md](./越前龙马.md)" in viking_fs.store[entity_overview_uri]
+ assert "**User:** alice" in viking_fs.store[preference_overview_uri]
+ assert "**Topic:** workflow.md" in viking_fs.store[preference_overview_uri]
+ assert "- [workflow.md](./workflow.md)" in viking_fs.store[preference_overview_uri]
+
@pytest.mark.asyncio
async def test_apply_operations_preserves_pre_resolved_multi_uris_for_new_page_ids(self):
registry = MagicMock()
diff --git a/tests/session/memory/test_resource_refs.py b/tests/session/memory/test_resource_refs.py
index ae9933f11..541b1cc73 100644
--- a/tests/session/memory/test_resource_refs.py
+++ b/tests/session/memory/test_resource_refs.py
@@ -6,6 +6,7 @@ from openviking.session.memory.utils.resource_refs import (
contains_resource_uri,
extract_resource_uris,
sync_memory_resource_refs,
+ unlink_resource_references_from_memory,
)
@@ -87,3 +88,39 @@ def test_sync_memory_resource_refs_keeps_bare_uri_clean_before_chinese_punctuati
"match_text": "昨天晚上我看了",
}
]
+
+
+def test_unlink_resource_references_preserves_visible_markdown_text():
+ resource_uri = "viking://resources/images/2026/06/12/yueqian_jpeg"
+ child_uri = f"{resource_uri}/child.jpeg"
+ mf = MemoryFile(
+ content=(f"用户保存了[越前龙马照片]({resource_uri})。\n用户也保存了[子图]({child_uri})。"),
+ extra_fields={
+ "resource_refs": [
+ {"resource_uri": resource_uri, "source": "content.write"},
+ {"resource_uri": child_uri, "source": "content.write"},
+ ]
+ },
+ )
+
+ changed = unlink_resource_references_from_memory(mf, resource_uri, recursive=False)
+
+ assert changed is True
+ assert mf.content == f"用户保存了越前龙马照片。\n用户也保存了[子图]({child_uri})。"
+ assert mf.extra_fields["resource_refs"] == [
+ {"resource_uri": child_uri, "source": "content.write"}
+ ]
+
+
+def test_unlink_resource_references_removes_bare_uri_but_keeps_sentence():
+ resource_uri = "viking://resources/images/2026/06/12/yueqian_jpeg"
+ mf = MemoryFile(
+ content=f"用户保存了越前龙马照片 {resource_uri}。",
+ extra_fields={"resource_refs": [{"resource_uri": resource_uri}]},
+ )
+
+ changed = unlink_resource_references_from_memory(mf, resource_uri)
+
+ assert changed is True
+ assert mf.content == "用户保存了越前龙马照片。"
+ assert "resource_refs" not in mf.extra_fields