Skip to content

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

feat: add user-scoped memory extraction policies (#3906)

agent6fc4d8fa57a1
diff --git a/docs/en/api/01-overview.md b/docs/en/api/01-overview.md
index f2f95f049..0dab5dee4 100644
--- a/docs/en/api/01-overview.md
+++ b/docs/en/api/01-overview.md
@@ -484,6 +484,8 @@ This catalog follows the routes actually mounted by the server. Each group headi
| DELETE | `/api/v1/admin/accounts/{account_id}` | Delete an account |
| POST | `/api/v1/admin/accounts/{account_id}/users` | Register a user |
| GET | `/api/v1/admin/accounts/{account_id}/users` | List users |
+| GET | `/api/v1/admin/accounts/{account_id}/users/{user_id}/settings` | Get a user's memory policy |
+| PATCH | `/api/v1/admin/accounts/{account_id}/users/{user_id}/settings` | Update a user's memory policy |
| DELETE | `/api/v1/admin/accounts/{account_id}/users/{user_id}` | Remove a user |
| PUT | `/api/v1/admin/accounts/{account_id}/users/{user_id}/role` | Promote a user to ADMIN |
| POST | `/api/v1/admin/accounts/{account_id}/users/{user_id}/key` | Regenerate a user key |
diff --git a/docs/en/api/05-sessions.md b/docs/en/api/05-sessions.md
index 4f2b1b853..a2222c627 100644
--- a/docs/en/api/05-sessions.md
+++ b/docs/en/api/05-sessions.md
@@ -1405,6 +1405,11 @@ Commit a session. Message archiving (Phase 1) completes immediately. Summary gen
| session_id | str | Yes | - | Session ID to commit |
| keep_recent_count | int | No | 0 | Number of recent live messages to retain (kept live, not archived) after commit. `0` (default) archives all messages. |
+The effective policy is resolved in this order: Session `.meta.json`, latest
+`settings/user_config.json`, then the kernel default. The fully resolved policy
+is stored in the queued task before Phase 2 starts. A completed task returns
+`effective_memory_policy` and `memory_policy_source` for diagnostics.
+
#### 3. Usage Examples
**HTTP API**
diff --git a/docs/en/api/08-admin.md b/docs/en/api/08-admin.md
index dc9499ec5..08f76c38d 100644
--- a/docs/en/api/08-admin.md
+++ b/docs/en/api/08-admin.md
@@ -117,6 +117,33 @@ Content-Type: application/json
Before an existing setting is replaced, it is backed up to
`/local/{account_id}/_system/setting.backup.json`.
+### user_settings
+
+ROOT can manage any User and ADMIN can manage Users in its own account. The
+User settings endpoint currently allowlists only `memory_policy`. Each target
+has its own `enabled` switch and `memory_types` filter. Agent memory types are
+self-only; configuring them for `peer` is rejected.
+
+```http
+GET /api/v1/admin/accounts/{account_id}/users/{user_id}/settings
+PATCH /api/v1/admin/accounts/{account_id}/users/{user_id}/settings
+Content-Type: application/json
+
+{
+ "memory_policy": {
+ "self": {"enabled": true, "memory_types": ["profile", "experiences"]},
+ "peer": {"enabled": false, "memory_types": []}
+ }
+}
+```
+
+The response contains the User-level `memory_policy`, expanded with its default
+memory types and Agent-memory dependencies. It is independent of the
+account-level Agent Evolution switch, which is managed through the dedicated
+account endpoint. Updates are backed up to the User's
+`settings/user_config.backup.json` before replacement. A Session without an
+explicit policy reads the latest User policy when it is committed.
+
---
### create_account
diff --git a/docs/zh/api/01-overview.md b/docs/zh/api/01-overview.md
index 7bb23870a..970c2dd02 100644
--- a/docs/zh/api/01-overview.md
+++ b/docs/zh/api/01-overview.md
@@ -479,6 +479,8 @@ JSON 输出 - 错误:
| DELETE | `/api/v1/admin/accounts/{account_id}` | 删除账号 |
| POST | `/api/v1/admin/accounts/{account_id}/users` | 注册用户 |
| GET | `/api/v1/admin/accounts/{account_id}/users` | 列出用户 |
+| GET | `/api/v1/admin/accounts/{account_id}/users/{user_id}/settings` | 获取用户记忆策略 |
+| PATCH | `/api/v1/admin/accounts/{account_id}/users/{user_id}/settings` | 更新用户记忆策略 |
| DELETE | `/api/v1/admin/accounts/{account_id}/users/{user_id}` | 移除用户 |
| PUT | `/api/v1/admin/accounts/{account_id}/users/{user_id}/role` | 将用户提升为 ADMIN |
| POST | `/api/v1/admin/accounts/{account_id}/users/{user_id}/key` | 重新生成用户 Key |
diff --git a/docs/zh/api/05-sessions.md b/docs/zh/api/05-sessions.md
index 9ceef9439..78ceb9e24 100644
--- a/docs/zh/api/05-sessions.md
+++ b/docs/zh/api/05-sessions.md
@@ -1377,6 +1377,10 @@ curl -X POST http://localhost:1933/api/v1/sessions/a1b2c3d4/used \
| session_id | str | 是 | - | 要提交的会话 ID |
| keep_recent_count | int | 否 | 0 | 提交后保留为 live 状态的最近消息数 (保持 live, 不归档)。`0` (默认) 归档全部消息。 |
+有效策略按 Session `.meta.json`、最新 `settings/user_config.json`、内核默认值的
+顺序解析。Phase 2 开始前会将完整有效策略固化到异步任务。任务完成结果返回
+`effective_memory_policy` 和 `memory_policy_source`,用于排障。
+
#### 3. 使用示例
**HTTP API**
diff --git a/docs/zh/api/08-admin.md b/docs/zh/api/08-admin.md
index 52967bce0..35a7dfdc3 100644
--- a/docs/zh/api/08-admin.md
+++ b/docs/zh/api/08-admin.md
@@ -115,6 +115,30 @@ Content-Type: application/json
覆盖已有配置前,内核会先备份到
`/local/{account_id}/_system/setting.backup.json`。
+### user_settings
+
+ROOT 可管理任意 User,ADMIN 仅可管理所属 account 内的 User。User 配置接口当前
+仅允许修改 `memory_policy`。`self` 和 `peer` 分别配置 `enabled` 与
+`memory_types`;Agent 记忆只允许写入 self,peer 配置 Agent 记忆类型会被拒绝。
+
+```http
+GET /api/v1/admin/accounts/{account_id}/users/{user_id}/settings
+PATCH /api/v1/admin/accounts/{account_id}/users/{user_id}/settings
+Content-Type: application/json
+
+{
+ "memory_policy": {
+ "self": {"enabled": true, "memory_types": ["profile", "experiences"]},
+ "peer": {"enabled": false, "memory_types": []}
+ }
+}
+```
+
+响应直接返回 User 级 `memory_policy`,并展开默认记忆类型和 Agent 记忆依赖;
+该结果不受 account 级 Agent 进化开关影响,Account 开关由独立接口管理。
+更新前会备份到该 User 的 `settings/user_config.backup.json`。未显式配置策略的
+Session 在 commit 时读取该 User 最新策略。
+
---
### create_account
diff --git a/openviking/server/config.py b/openviking/server/config.py
index 0bdd74889..501094350 100644
--- a/openviking/server/config.py
+++ b/openviking/server/config.py
@@ -3,7 +3,7 @@
"""Server configuration for OpenViking HTTP Server."""
import sys
-from typing import Dict, List, Literal, Optional
+from typing import Any, Dict, List, Literal, Optional
from pydantic import BaseModel, Field, ValidationError, field_validator
@@ -103,6 +103,7 @@ class UserConfig(BaseModel):
"""User configuration values that can be defaulted or initialized."""
add_targets: AddTargetsConfig = Field(default_factory=AddTargetsConfig)
+ memory_policy: Optional[Dict[str, Any]] = None
agent_evolution: DeprecatedUserAgentEvolutionConfig = Field(
default_factory=DeprecatedUserAgentEvolutionConfig,
exclude=True,
@@ -110,6 +111,15 @@ class UserConfig(BaseModel):
model_config = {"extra": "forbid"}
+ @field_validator("memory_policy", mode="before")
+ @classmethod
+ def validate_memory_policy(cls, value: Any) -> Optional[Dict[str, Any]]:
+ if value is None:
+ return None
+ from openviking.session.memory_policy import MemoryPolicy
+
+ return MemoryPolicy.from_dict(value).to_dict()
+
class MetricsAccountDimensionConfig(BaseModel):
"""Account-dimension configuration for metrics label injection."""
diff --git a/openviking/server/routers/admin.py b/openviking/server/routers/admin.py
index df626ea19..aa6ca8c4a 100644
--- a/openviking/server/routers/admin.py
+++ b/openviking/server/routers/admin.py
@@ -25,7 +25,13 @@ from openviking.server.config import ServerConfig, UserConfig
from openviking.server.dependencies import get_service
from openviking.server.identity import RequestContext, Role
from openviking.server.models import Response
-from openviking.server.user_config import validate_add_targets, write_user_config
+from openviking.server.user_config import (
+ read_user_config,
+ validate_add_targets,
+ validate_user_memory_policy,
+ write_user_config,
+ write_user_memory_policy,
+)
from openviking.service.legacy_migration import LegacyDataMigration
from openviking.service.task_store import (
SYSTEM_TASK_ACCOUNT_ID,
@@ -34,6 +40,8 @@ from openviking.service.task_store import (
from openviking.service.task_tracker import (
get_task_tracker,
)
+from openviking.session.memory.memory_type_registry import MemoryTypeRegistry
+from openviking.session.memory_policy import MemoryPolicy
from openviking.storage.viking_fs import get_viking_fs
from openviking_cli.exceptions import (
FailedPreconditionError,
@@ -80,6 +88,12 @@ class SetAgentEvolutionRequest(BaseModel):
enabled: bool
+class UserSettingsPatch(BaseModel):
+ memory_policy: dict
+
+ model_config = {"extra": "forbid"}
+
+
def _agent_evolution_account_id(ctx: RequestContext) -> str:
if ctx.role == Role.ROOT:
return get_openviking_config().default_account
@@ -177,7 +191,7 @@ def _has_add_targets(user_config: UserConfig | None) -> bool:
def _has_initial_user_config(user_config: UserConfig | None) -> bool:
- return _has_add_targets(user_config)
+ return bool(_has_add_targets(user_config) or (user_config and user_config.memory_policy))
def _validate_initial_user_config(
@@ -185,15 +199,18 @@ def _validate_initial_user_config(
user_ctx: RequestContext,
user_config: UserConfig | None,
) -> None:
- if not _has_add_targets(user_config):
+ if not _has_initial_user_config(user_config):
return
if service.viking_fs is None:
raise FailedPreconditionError("OpenViking service is not initialized.")
- validate_add_targets(
- user_config.add_targets,
- ctx=user_ctx,
- viking_fs=service.viking_fs,
- )
+ if _has_add_targets(user_config):
+ validate_add_targets(
+ user_config.add_targets,
+ ctx=user_ctx,
+ viking_fs=service.viking_fs,
+ )
+ if user_config is not None:
+ validate_user_memory_policy(user_config.memory_policy)
async def _write_initial_user_config(
@@ -206,6 +223,31 @@ async def _write_initial_user_config(
await write_user_config(service.viking_fs, user_ctx, user_config)
+def _check_user_exists(request: Request, account_id: str, user_id: str) -> None:
+ manager = _get_api_key_manager(request)
+ if not manager.has_user(account_id, user_id):
+ raise NotFoundError(user_id, "user")
+
+
+def _user_settings_result(
+ account_id: str,
+ user_id: str,
+ user_config: UserConfig,
+) -> dict:
+ policy = MemoryPolicy.from_dict(user_config.memory_policy)
+ known_memory_types = set(MemoryTypeRegistry().list_names(include_disabled=False))
+ policy.validate_memory_types(known_memory_types)
+ memory_policy = policy.resolve(
+ known_memory_types,
+ agent_evolution_enabled=True,
+ )
+ return {
+ "account_id": account_id,
+ "user_id": user_id,
+ "memory_policy": memory_policy.to_dict(),
+ }
+
+
async def _run_legacy_migration_task(
task_id: str,
migration: LegacyDataMigration,
@@ -467,6 +509,60 @@ async def list_users(
return Response(status="ok", result=users)
[email protected]("/accounts/{account_id}/users/{user_id}/settings")
+@require_auth_root_or_admin
+async def get_user_settings(
+ request: Request,
+ account_id: str = Path(..., description="Account ID"),
+ user_id: str = Path(..., description="User ID"),
+ ctx: RequestContext = Depends(get_request_context),
+):
+ """Return the configured and effective memory policy for one User."""
+ _check_account_access(ctx, account_id)
+ _check_account_exists(request, account_id)
+ _check_user_exists(request, account_id, user_id)
+ service = get_service()
+ if service.viking_fs is None:
+ raise FailedPreconditionError("OpenViking service is not initialized.")
+ user_ctx = RequestContext(
+ user=UserIdentifier(account_id, user_id),
+ role=Role.USER,
+ )
+ user_config = await read_user_config(service.viking_fs, user_ctx)
+ return Response(
+ status="ok",
+ result=_user_settings_result(account_id, user_id, user_config),
+ )
+
+
[email protected]("/accounts/{account_id}/users/{user_id}/settings")
+@require_auth_root_or_admin
+async def patch_user_settings(
+ body: UserSettingsPatch,
+ request: Request,
+ account_id: str = Path(..., description="Account ID"),
+ user_id: str = Path(..., description="User ID"),
+ ctx: RequestContext = Depends(get_request_context),
+):
+ """Update the allowlisted User memory policy without restarting the server."""
+ _check_account_access(ctx, account_id)
+ _check_account_exists(request, account_id)
+ _check_user_exists(request, account_id, user_id)
+ service = get_service()
+ if service.viking_fs is None:
+ raise FailedPreconditionError("OpenViking service is not initialized.")
+ user_ctx = RequestContext(
+ user=UserIdentifier(account_id, user_id),
+ role=Role.USER,
+ )
+ await write_user_memory_policy(service.viking_fs, user_ctx, body.memory_policy)
+ user_config = await read_user_config(service.viking_fs, user_ctx)
+ return Response(
+ status="ok",
+ result=_user_settings_result(account_id, user_id, user_config),
+ )
+
+
@router.delete("/accounts/{account_id}/users/{user_id}", status_code=202)
@require_auth_root_or_admin
async def remove_user(
diff --git a/openviking/server/user_config.py b/openviking/server/user_config.py
index 908d5a858..02380ebff 100644
--- a/openviking/server/user_config.py
+++ b/openviking/server/user_config.py
@@ -33,6 +33,10 @@ def user_config_uri(ctx: RequestContext) -> str:
return f"{canonical_user_root(ctx)}/settings/user_config.json"
+def user_config_backup_uri(ctx: RequestContext) -> str:
+ return f"{canonical_user_root(ctx)}/settings/user_config.backup.json"
+
+
@asynccontextmanager
async def _user_config_lock(
viking_fs: VikingFS,
@@ -69,6 +73,17 @@ def _ensure_mutable(viking_fs: VikingFS, uri: str, ctx: RequestContext) -> None:
ensure(uri, ctx)
+def validate_user_memory_policy(memory_policy: Optional[dict[str, Any]]) -> None:
+ if memory_policy is None:
+ return
+ from openviking.session.memory.memory_type_registry import MemoryTypeRegistry
+ from openviking.session.memory_policy import MemoryPolicy
+
+ MemoryPolicy.from_dict(memory_policy).validate_memory_types(
+ set(MemoryTypeRegistry().list_names(include_disabled=False))
+ )
+
+
def validate_resource_add_target(
uri: str,
*,
@@ -151,17 +166,33 @@ async def update_user_config(
before = current.model_dump()
result = updater(current)
validate_add_targets(current.add_targets, ctx=ctx, viking_fs=viking_fs)
+ validate_user_memory_policy(current.memory_policy)
if current.model_dump() != before:
+ before_content = json.dumps(before, ensure_ascii=False, sort_keys=True)
await viking_fs.write_file(
- uri,
- json.dumps(
- current.model_dump(exclude_none=True),
- ensure_ascii=False,
- sort_keys=True,
- ),
+ user_config_backup_uri(ctx),
+ before_content,
ctx=ctx,
- lease_ref=handle,
)
+ try:
+ await viking_fs.write_file(
+ uri,
+ json.dumps(
+ current.model_dump(exclude_none=True),
+ ensure_ascii=False,
+ sort_keys=True,
+ ),
+ ctx=ctx,
+ lease_ref=handle,
+ )
+ except Exception:
+ await viking_fs.write_file(
+ uri,
+ before_content,
+ ctx=ctx,
+ lease_ref=handle,
+ )
+ raise
return result
@@ -171,6 +202,7 @@ async def write_user_config(
user_config: UserConfig,
) -> ResolvedAddTargets:
runtime = validate_add_targets(user_config.add_targets, ctx=ctx, viking_fs=viking_fs)
+ validate_user_memory_policy(user_config.memory_policy)
uri = user_config_uri(ctx)
async with _user_config_lock(viking_fs, uri, ctx) as handle:
await viking_fs.write_file(
@@ -221,6 +253,30 @@ async def delete_user_add_targets(viking_fs: VikingFS, ctx: RequestContext) -> N
await update_user_config(viking_fs, ctx, _clear)
+async def read_user_memory_policy(
+ viking_fs: VikingFS,
+ ctx: RequestContext,
+) -> Optional[dict[str, Any]]:
+ return (await read_user_config(viking_fs, ctx)).memory_policy
+
+
+async def write_user_memory_policy(
+ viking_fs: VikingFS,
+ ctx: RequestContext,
+ memory_policy: dict[str, Any],
+) -> dict[str, Any]:
+ normalized = UserConfig(memory_policy=memory_policy).memory_policy
+ if normalized is None:
+ raise InvalidArgumentError("memory_policy must be an object")
+ validate_user_memory_policy(normalized)
+
+ def _set(user_config: UserConfig) -> None:
+ user_config.memory_policy = normalized
+
+ await update_user_config(viking_fs, ctx, _set)
+ return normalized
+
+
async def effective_resource_add_target(
*,
viking_fs: VikingFS,
diff --git a/openviking/service/session_service.py b/openviking/service/session_service.py
index 0273a1ba8..9953572d6 100644
--- a/openviking/service/session_service.py
+++ b/openviking/service/session_service.py
@@ -15,6 +15,7 @@ from openviking.core.namespace import canonical_session_uri
from openviking.server.agent_evolution_config import AgentEvolutionConfigProvider
from openviking.server.config import AgentEvolutionConfig, ToolOutputExternalizationConfig
from openviking.server.identity import RequestContext
+from openviking.server.user_config import read_user_config
from openviking.service.session_auto_commit import (
compute_next_check_at,
get_idle_timeout_seconds,
@@ -200,9 +201,15 @@ class SessionService:
agent_evolution_enabled_provider=lambda: self.get_agent_evolution_enabled(
ctx.account_id
),
+ memory_policy_provider=lambda: self._get_user_memory_policy(ctx),
usage_reporter=self._usage_reporter,
)
+ async def _get_user_memory_policy(self, ctx: RequestContext) -> Optional[Dict[str, Any]]:
+ """Read the latest persisted User policy at commit time."""
+ config = await read_user_config(self._viking_fs, ctx)
+ return config.memory_policy
+
async def create(
self,
ctx: RequestContext,
@@ -240,7 +247,14 @@ class SessionService:
policy.validate_memory_types(
set(MemoryTypeRegistry().list_names(include_disabled=False))
)
- session.meta.memory_policy = policy.to_dict()
+ has_target_memory_types = not isinstance(memory_policy, dict) or any(
+ isinstance(memory_policy.get(target), dict)
+ and "memory_types" in memory_policy[target]
+ for target in ("self", "peer")
+ )
+ session.meta.memory_policy = (
+ policy.to_dict() if has_target_memory_types else policy.to_legacy_dict()
+ )
# Auto-commit is enabled when the caller supplies a policy, or when
# the server default turns it on. Absent both, it stays disabled.
if update_auto_commit_policy and auto_commit_policy is None:
diff --git a/openviking/session/compressor_v3.py b/openviking/session/compressor_v3.py
index c568d3b86..22840e3f3 100644
--- a/openviking/session/compressor_v3.py
+++ b/openviking/session/compressor_v3.py
@@ -359,6 +359,8 @@ class SessionCompressorV3:
latest_archive_overview: str = "",
archive_uri: Optional[str] = None,
allowed_memory_types: Optional[set[str]] = None,
+ allowed_self_memory_types: Optional[set[str]] = None,
+ allowed_peer_memory_types: Optional[set[str]] = None,
agent_evolution_enabled: bool = True,
allow_self_memory: bool = True,
allowed_peer_ids: Optional[set[str]] = None,
@@ -371,12 +373,22 @@ class SessionCompressorV3:
else set(allowed_memory_types)
)
allowed_memory_types = effective_types - AGENT_EVOLUTION_MEMORY_TYPES
+ if allowed_self_memory_types is not None:
+ allowed_self_memory_types = (
+ set(allowed_self_memory_types) - AGENT_EVOLUTION_MEMORY_TYPES
+ )
+ if allowed_peer_memory_types is not None:
+ allowed_peer_memory_types = (
+ set(allowed_peer_memory_types) - AGENT_EVOLUTION_MEMORY_TYPES
+ )
message_list = list(messages)
- fast_path_case = _training_case_from_first_message(
- message_list,
- allowed_memory_types,
+ self_types = (
+ allowed_self_memory_types
+ if allowed_self_memory_types is not None
+ else allowed_memory_types
)
+ fast_path_case = _training_case_from_first_message(message_list, self_types)
try:
if fast_path_case is not None:
return await self._commit_training_case_fast_path(
@@ -387,7 +399,7 @@ class SessionCompressorV3:
archive_uri=archive_uri or "",
strict_extract_errors=strict_extract_errors,
agent_evolution_enabled=agent_evolution_enabled,
- allowed_memory_types=allowed_memory_types,
+ allowed_memory_types=self_types,
)
result = await self._extract_user_memories(
@@ -399,14 +411,14 @@ class SessionCompressorV3:
latest_archive_overview=latest_archive_overview,
archive_uri=archive_uri,
allowed_memory_types=allowed_memory_types,
+ allowed_self_memory_types=allowed_self_memory_types,
+ allowed_peer_memory_types=allowed_peer_memory_types,
allow_self_memory=allow_self_memory,
allowed_peer_ids=allowed_peer_ids,
event_search_tags=event_search_tags,
)
- agent_memory_types = _allowed_agent_memory_types(allowed_memory_types)
- cases_allowed = (
- allowed_memory_types is None or _CASES_MEMORY_TYPE in allowed_memory_types
- )
+ agent_memory_types = _allowed_agent_memory_types(self_types)
+ cases_allowed = self_types is None or _CASES_MEMORY_TYPE in self_types
session_skills_enabled = self._session_skill_extraction_enabled()
if (
agent_evolution_enabled
@@ -600,6 +612,8 @@ class SessionCompressorV3:
latest_archive_overview: str = "",
archive_uri: Optional[str] = None,
allowed_memory_types: Optional[set[str]] = None,
+ allowed_self_memory_types: Optional[set[str]] = None,
+ allowed_peer_memory_types: Optional[set[str]] = None,
allow_self_memory: bool = True,
allowed_peer_ids: Optional[set[str]] = None,
event_search_tags: Optional[List[str]] = None,
@@ -623,7 +637,11 @@ class SessionCompressorV3:
if allow_self_memory:
await registry.initialize_memory_files(
ctx,
- allowed_memory_types=allowed_memory_types,
+ allowed_memory_types=(
+ allowed_self_memory_types
+ if allowed_self_memory_types is not None
+ else allowed_memory_types
+ ),
)
context_provider = SessionExtractContextProvider(
@@ -642,6 +660,8 @@ class SessionCompressorV3:
allowed_memory_types=allowed_memory_types,
allow_self=allow_self_memory,
allowed_peer_ids=allowed_peer_ids,
+ allowed_self_memory_types=allowed_self_memory_types,
+ allowed_peer_memory_types=allowed_peer_memory_types,
)
isolation_handler.prepare_messages()
context_provider._isolation_handler = isolation_handler
@@ -682,6 +702,8 @@ class SessionCompressorV3:
"allowed_memory_types": allowed_memory_types,
"allow_self": allow_self_memory,
"allowed_peer_ids": allowed_peer_ids,
+ "allowed_self_memory_types": allowed_self_memory_types,
+ "allowed_peer_memory_types": allowed_peer_memory_types,
},
metadata={
"source_extraction_id": extraction_id,
diff --git a/openviking/session/memory/memory_isolation_handler.py b/openviking/session/memory/memory_isolation_handler.py
index d7ffd2392..180922013 100644
--- a/openviking/session/memory/memory_isolation_handler.py
+++ b/openviking/session/memory/memory_isolation_handler.py
@@ -43,6 +43,8 @@ class MemoryIsolationHandler:
allowed_memory_types: Optional[Set[str]] = None,
allow_self: bool = True,
allowed_peer_ids: Optional[Set[str]] = None,
+ allowed_self_memory_types: Optional[Set[str]] = None,
+ allowed_peer_memory_types: Optional[Set[str]] = None,
):
self.ctx = ctx
self._extract_context = extract_context
@@ -51,6 +53,16 @@ class MemoryIsolationHandler:
if allowed_memory_types is not None
else None
)
+ self.allowed_self_memory_types = (
+ {str(item) for item in allowed_self_memory_types}
+ if allowed_self_memory_types is not None
+ else self.allowed_memory_types
+ )
+ self.allowed_peer_memory_types = (
+ {str(item) for item in allowed_peer_memory_types}
+ if allowed_peer_memory_types is not None
+ else self.allowed_memory_types
+ )
peer_ids = {
item
for item in (safe_peer_id(item) for item in allowed_peer_ids or set())
@@ -125,11 +137,23 @@ class MemoryIsolationHandler:
memory_type = getattr(memory_type_schema, "memory_type", "")
if memory_type in _INTERNAL_MEMORY_TYPES:
return True
- if self.allowed_memory_types is not None and memory_type not in self.allowed_memory_types:
- return False
- if not self.allow_self and not getattr(memory_type_schema, "peer_enabled", True):
- return False
- return True
+ self_allowed = self.allow_self and self._allows_self_type(memory_type)
+ peer_allowed = (
+ self.allow_peer
+ and getattr(memory_type_schema, "peer_enabled", True)
+ and self._allows_peer_type(memory_type)
+ )
+ return self_allowed or peer_allowed
+
+ def _allows_self_type(self, memory_type: str) -> bool:
+ return (
+ self.allowed_self_memory_types is None or memory_type in self.allowed_self_memory_types
+ )
+
+ def _allows_peer_type(self, memory_type: str) -> bool:
+ return (
+ self.allowed_peer_memory_types is None or memory_type in self.allowed_peer_memory_types
+ )
def _can_write_peer(self, peer_id: str) -> bool:
return self.allow_peer and peer_id in self.allowed_peer_ids
@@ -180,9 +204,14 @@ class MemoryIsolationHandler:
user_id = self.ctx.user.user_id if self.ctx and self.ctx.user else "default"
user_space = user_id
user_spaces: List[str] = []
- if self.allow_self:
+ memory_type = getattr(memory_type_schema, "memory_type", "")
+ if self.allow_self and self._allows_self_type(memory_type):
user_spaces.append(user_space)
- if self.allow_peer and getattr(memory_type_schema, "peer_enabled", True):
+ if (
+ self.allow_peer
+ and getattr(memory_type_schema, "peer_enabled", True)
+ and self._allows_peer_type(memory_type)
+ ):
for peer_id in sorted(self.allowed_peer_ids):
user_spaces.append(peer_user_space(user_space, peer_id))
@@ -247,12 +276,15 @@ class MemoryIsolationHandler:
user_id = self.ctx.user.user_id
operation.memory_fields["user_id"] = user_id
+ memory_type = getattr(memory_type_schema, "memory_type", "")
target_ids: List[str] = []
has_ranges = operation.memory_fields.get("ranges") is not None
if not getattr(memory_type_schema, "peer_enabled", True):
operation.memory_fields.pop("peer_id", None)
- target_ids = [_SELF_PEER_ID] if self.allow_self else []
+ target_ids = (
+ [_SELF_PEER_ID] if self.allow_self and self._allows_self_type(memory_type) else []
+ )
elif operation.memory_fields.get("ranges") is not None:
target_ids, can_fallback = self._range_targets(
operation.memory_fields.get("ranges"),
@@ -263,9 +295,11 @@ class MemoryIsolationHandler:
target_ids = [fallback_target]
operation.memory_fields.pop("peer_id", None)
else:
- target_id = self._resolve_operation_target_id(
- operation.memory_fields.get("peer_id"),
- )
+ raw_peer_id = operation.memory_fields.get("peer_id")
+ if raw_peer_id in (None, "") and not self._allows_self_type(memory_type):
+ target_id = self._unique_peer_target_id_in_messages()
+ else:
+ target_id = self._resolve_operation_target_id(raw_peer_id)
if target_id:
target_ids = [target_id]
if target_id == _SELF_PEER_ID:
@@ -278,6 +312,15 @@ class MemoryIsolationHandler:
if not target_ids:
return []
+ target_ids = [
+ target_id
+ for target_id in target_ids
+ if (target_id == _SELF_PEER_ID and self._allows_self_type(memory_type))
+ or (target_id != _SELF_PEER_ID and self._allows_peer_type(memory_type))
+ ]
+ if not target_ids:
+ return []
+
# 文件
uris = set()
user_space = user_id
diff --git a/openviking/session/memory/streaming_memory_updater.py b/openviking/session/memory/streaming_memory_updater.py
index 05c6e087b..67153a72b 100644
--- a/openviking/session/memory/streaming_memory_updater.py
+++ b/openviking/session/memory/streaming_memory_updater.py
@@ -1836,6 +1836,8 @@ def _make_isolation_handler(
allowed_memory_types=options.get("allowed_memory_types"),
allow_self=options.get("allow_self", True),
allowed_peer_ids=options.get("allowed_peer_ids"),
+ allowed_self_memory_types=options.get("allowed_self_memory_types"),
+ allowed_peer_memory_types=options.get("allowed_peer_memory_types"),
)
diff --git a/openviking/session/memory_policy.py b/openviking/session/memory_policy.py
index a56ffec76..71a375cb2 100644
--- a/openviking/session/memory_policy.py
+++ b/openviking/session/memory_policy.py
@@ -15,10 +15,14 @@ from openviking.session.memory.constants import (
from openviking_cli.exceptions import InvalidArgumentError
_POLICY_KEYS = {"self", "peer", "memory_types", "working_memory"}
-_TARGET_KEYS = {"enabled"}
+_TARGET_KEYS = {"enabled", "memory_types"}
+_WORKING_MEMORY_KEYS = {"enabled"}
_TRUE_STRINGS = {"1", "true", "yes", "on"}
_FALSE_STRINGS = {"", "0", "false", "no", "off"}
+AGENT_MEMORY_TYPES = {"cases", "trajectories", "experiences"}
+_EXPERIENCE_DEPENDENCIES = AGENT_MEMORY_TYPES
+
def _memory_policy_shape_error(key: str) -> str:
if key == "working_memory":
@@ -29,7 +33,7 @@ def _memory_policy_shape_error(key: str) -> str:
def _memory_policy_keys_error(key: str) -> str:
if key == "working_memory":
return "memory_policy.working_memory supports only: enabled"
- return "memory_policy target supports only: enabled"
+ return "memory_policy target supports only: enabled, memory_types"
def _parse_enabled(value: Any, *, key: str) -> bool:
@@ -48,51 +52,78 @@ def _parse_enabled(value: Any, *, key: str) -> bool:
if normalized in _FALSE_STRINGS:
return False
- # Preserve the permissive pre-v0.5 behavior for uncommon legacy values.
- # This avoids breaking persisted policy dictionaries while callers migrate
- # to genuine JSON booleans.
return bool(value)
-def _target_enabled(data: Any, *, default_enabled: bool, key: str = "target") -> bool:
- if data is None:
- return default_enabled
- if not isinstance(data, dict):
- raise InvalidArgumentError(_memory_policy_shape_error(key))
- extra_keys = set(data) - _TARGET_KEYS
- if extra_keys:
- raise InvalidArgumentError(_memory_policy_keys_error(key))
- if "enabled" not in data:
- return default_enabled
- return _parse_enabled(data["enabled"], key=key)
-
-
-def _parse_memory_types(data: Any) -> Optional[set[str]]:
+def _parse_memory_types(
+ data: Any,
+ *,
+ field: str,
+ normalize_agent_dependencies: bool = False,
+) -> Optional[set[str]]:
if data is None:
return None
if not isinstance(data, list):
- raise InvalidArgumentError("memory_policy.memory_types must be a list")
+ raise InvalidArgumentError(f"{field} must be a list")
memory_types = set()
for item in data:
if not isinstance(item, str) or not item:
- raise InvalidArgumentError("memory_policy.memory_types must contain non-empty strings")
+ raise InvalidArgumentError(f"{field} must contain non-empty strings")
memory_types.add(item)
- if EXPERIENCE_MEMORY_TYPE in memory_types:
- memory_types.update(AGENT_EVOLUTION_MEMORY_TYPES)
- else:
- memory_types.difference_update(AGENT_EVOLUTION_MEMORY_TYPES)
+ if normalize_agent_dependencies:
+ if EXPERIENCE_MEMORY_TYPE in memory_types:
+ memory_types.update(AGENT_EVOLUTION_MEMORY_TYPES)
+ else:
+ memory_types.difference_update(AGENT_EVOLUTION_MEMORY_TYPES)
return memory_types
+def _parse_target(
+ data: Any,
+ *,
+ default_enabled: bool,
+ key: str,
+) -> tuple[bool, Optional[set[str]], bool]:
+ if data is None:
+ return default_enabled, None, False
+ if not isinstance(data, dict):
+ raise InvalidArgumentError(_memory_policy_shape_error(key))
+ allowed_keys = _WORKING_MEMORY_KEYS if key == "working_memory" else _TARGET_KEYS
+ extra_keys = set(data) - allowed_keys
+ if extra_keys:
+ raise InvalidArgumentError(_memory_policy_keys_error(key))
+ enabled = _parse_enabled(data["enabled"], key=key) if "enabled" in data else default_enabled
+ if key == "working_memory":
+ return enabled, None, False
+ has_memory_types = "memory_types" in data
+ memory_types = _parse_memory_types(
+ data.get("memory_types"),
+ field=f"memory_policy.{key}.memory_types",
+ )
+ return enabled, memory_types, has_memory_types
+
+
@dataclass
class MemoryPolicy:
- """Effective memory policy for one commit."""
+ """Effective memory policy for one commit.
+
+ ``self`` and ``peer`` have independent type filters. The legacy top-level
+ ``memory_types`` input is still accepted and normalized into this shape.
+ """
self_enabled: bool = True
peer_enabled: bool = True
- memory_types: Optional[set[str]] = None
+ self_memory_types: Optional[set[str]] = None
+ peer_memory_types: Optional[set[str]] = None
working_memory_enabled: bool = True
+ @property
+ def memory_types(self) -> Optional[set[str]]:
+ """Compatibility view used by callers that only need the union."""
+ if self.self_memory_types is None or self.peer_memory_types is None:
+ return None
+ return set(self.self_memory_types) | set(self.peer_memory_types)
+
@classmethod
def default(cls) -> "MemoryPolicy":
return cls()
@@ -110,31 +141,107 @@ class MemoryPolicy:
raise InvalidArgumentError(
"memory_policy supports only: " + ", ".join(sorted(_POLICY_KEYS))
)
+
+ self_enabled, self_types, self_types_explicit = _parse_target(
+ data.get("self"), default_enabled=True, key="self"
+ )
+ peer_enabled, peer_types, peer_types_explicit = _parse_target(
+ data.get("peer"), default_enabled=True, key="peer"
+ )
+ working_enabled, _, _ = _parse_target(
+ data.get("working_memory"), default_enabled=True, key="working_memory"
+ )
+
+ legacy_types = _parse_memory_types(
+ data.get("memory_types"),
+ field="memory_policy.memory_types",
+ normalize_agent_dependencies=True,
+ )
+ if not self_types_explicit:
+ self_types = None if legacy_types is None else set(legacy_types)
+ if not peer_types_explicit:
+ peer_types = None if legacy_types is None else set(legacy_types) - AGENT_MEMORY_TYPES
+
+ if peer_types and peer_types & AGENT_MEMORY_TYPES:
+ raise InvalidArgumentError(
+ "memory_policy.peer.memory_types does not support agent memory types: "
+ + ", ".join(sorted(peer_types & AGENT_MEMORY_TYPES))
+ )
+
return cls(
- self_enabled=_target_enabled(data.get("self"), default_enabled=True, key="self"),
- peer_enabled=_target_enabled(data.get("peer"), default_enabled=True, key="peer"),
- memory_types=_parse_memory_types(data.get("memory_types")),
- working_memory_enabled=_target_enabled(
- data.get("working_memory"), default_enabled=True, key="working_memory"
- ),
+ self_enabled=self_enabled,
+ peer_enabled=peer_enabled,
+ self_memory_types=self_types,
+ peer_memory_types=peer_types,
+ working_memory_enabled=working_enabled,
)
def validate_memory_types(self, known_memory_types: set[str]) -> None:
- if self.memory_types is None:
- return
- unknown = self.memory_types - known_memory_types
+ configured = set()
+ if self.self_memory_types is not None:
+ configured.update(self.self_memory_types)
+ if self.peer_memory_types is not None:
+ configured.update(self.peer_memory_types)
+ unknown = configured - known_memory_types
if unknown:
raise InvalidArgumentError(
- "Unknown memory_policy.memory_types: " + ", ".join(sorted(unknown))
+ "Unknown memory_policy memory types: " + ", ".join(sorted(unknown))
)
+ def resolve(
+ self,
+ known_memory_types: set[str],
+ *,
+ agent_evolution_enabled: bool,
+ ) -> "MemoryPolicy":
+ """Expand defaults and apply the account-scoped Agent switch."""
+ self_types = (
+ set(known_memory_types)
+ if self.self_memory_types is None
+ else set(self.self_memory_types)
+ )
+ if "experiences" in self_types:
+ self_types.update(_EXPERIENCE_DEPENDENCIES)
+ else:
+ self_types.difference_update(AGENT_MEMORY_TYPES)
+ peer_types = (
+ set(known_memory_types) - AGENT_MEMORY_TYPES
+ if self.peer_memory_types is None
+ else set(self.peer_memory_types)
+ )
+ if not agent_evolution_enabled:
+ self_types -= AGENT_MEMORY_TYPES
+ return MemoryPolicy(
+ self_enabled=self.self_enabled,
+ peer_enabled=self.peer_enabled,
+ self_memory_types=self_types,
+ peer_memory_types=peer_types,
+ working_memory_enabled=self.working_memory_enabled,
+ )
+
def to_dict(self) -> dict[str, Any]:
+ self_target: dict[str, Any] = {"enabled": self.self_enabled}
+ peer_target: dict[str, Any] = {"enabled": self.peer_enabled}
+ if self.self_memory_types is not None:
+ self_target["memory_types"] = sorted(self.self_memory_types)
+ if self.peer_memory_types is not None:
+ peer_target["memory_types"] = sorted(self.peer_memory_types)
+ data: dict[str, Any] = {
+ "self": self_target,
+ "peer": peer_target,
+ }
+ if not self.working_memory_enabled:
+ data["working_memory"] = {"enabled": False}
+ return data
+
+ def to_legacy_dict(self) -> dict[str, Any]:
+ """Serialize a policy parsed from the legacy shared memory_types shape."""
data: dict[str, Any] = {
"self": {"enabled": self.self_enabled},
"peer": {"enabled": self.peer_enabled},
}
if not self.working_memory_enabled:
data["working_memory"] = {"enabled": False}
- if self.memory_types is not None:
- data["memory_types"] = sorted(self.memory_types)
+ if self.self_memory_types is not None:
+ data["memory_types"] = sorted(self.self_memory_types)
return data
diff --git a/openviking/session/session.py b/openviking/session/session.py
index f395da841..d3fa58d7d 100644
--- a/openviking/session/session.py
+++ b/openviking/session/session.py
@@ -105,8 +105,6 @@ def _enabled_memory_types() -> set[str]:
def _validate_memory_policy_types(policy: MemoryPolicy) -> None:
- if policy.memory_types is None:
- return
policy.validate_memory_types(_enabled_memory_types())
@@ -115,24 +113,30 @@ def _apply_agent_evolution_setting(
*,
agent_evolution_enabled: bool,
) -> MemoryPolicy:
- if agent_evolution_enabled:
- return policy
- effective_types = (
- _enabled_memory_types() if policy.memory_types is None else set(policy.memory_types)
- )
- effective_types -= AGENT_EVOLUTION_MEMORY_TYPES
- return MemoryPolicy(
- self_enabled=policy.self_enabled,
- peer_enabled=policy.peer_enabled,
- memory_types=effective_types,
- working_memory_enabled=policy.working_memory_enabled,
+ return policy.resolve(
+ _enabled_memory_types(),
+ agent_evolution_enabled=agent_evolution_enabled,
)
-def _effective_memory_types(policy: MemoryPolicy) -> set[str]:
- if policy.memory_types is None:
+def _effective_self_memory_types(policy: MemoryPolicy) -> set[str]:
+ if not policy.self_enabled:
+ return set()
+ if policy.self_memory_types is None:
return _enabled_memory_types()
- return set(policy.memory_types)
+ return set(policy.self_memory_types)
+
+
+def _effective_peer_memory_types(policy: MemoryPolicy) -> set[str]:
+ if not policy.peer_enabled:
+ return set()
+ if policy.peer_memory_types is None:
+ return _enabled_memory_types() - AGENT_EVOLUTION_MEMORY_TYPES
+ return set(policy.peer_memory_types)
+
+
+def _effective_memory_types(policy: MemoryPolicy) -> set[str]:
+ return _effective_self_memory_types(policy) | _effective_peer_memory_types(policy)
def _agent_memory_skip_reason(
@@ -186,6 +190,8 @@ class _MemoryExtractionScope:
allow_self_memory: bool
allowed_peer_ids: set[str]
include_session_skills: bool
+ self_memory_types: set[str]
+ peer_memory_types: set[str]
memory_types: Optional[set[str]]
@@ -198,12 +204,29 @@ def _resolve_memory_extraction_scope(
) -> _MemoryExtractionScope:
allow_self_memory = policy.self_enabled
allowed_peer_ids = _message_peer_ids(messages) if policy.peer_enabled else set()
+ configured_scope_types: list[Optional[set[str]]] = []
+ if allow_self_memory:
+ configured_scope_types.append(policy.self_memory_types)
+ if allowed_peer_ids:
+ configured_scope_types.append(policy.peer_memory_types)
+ if not configured_scope_types:
+ combined_memory_types: Optional[set[str]] = set()
+ elif any(memory_types is None for memory_types in configured_scope_types):
+ combined_memory_types = None
+ else:
+ combined_memory_types = set().union(
+ *(memory_types or set() for memory_types in configured_scope_types)
+ )
return _MemoryExtractionScope(
allow_self_memory=allow_self_memory,
allowed_peer_ids=allowed_peer_ids,
include_session_skills=config_session_skill_extraction_enabled and allow_self_memory,
- memory_types=policy.memory_types,
+ self_memory_types=(_effective_self_memory_types(policy) if allow_self_memory else set()),
+ peer_memory_types=(
+ _effective_peer_memory_types(policy) if allowed_peer_ids else set()
+ ),
+ memory_types=combined_memory_types,
)
@@ -595,6 +618,7 @@ class Session:
agent_evolution_enabled: bool = True,
usage_reporter: Optional["UsageReporter"] = None,
agent_evolution_enabled_provider: Optional[Callable[[], bool | Awaitable[bool]]] = None,
+ memory_policy_provider: Optional[Callable[[], Any | Awaitable[Any]]] = None,
):
self._viking_fs = viking_fs
self._vikingdb_manager = vikingdb_manager
@@ -627,8 +651,15 @@ class Session:
)
self._agent_evolution_enabled = agent_evolution_enabled
self._agent_evolution_enabled_provider = agent_evolution_enabled_provider
+ self._memory_policy_provider = memory_policy_provider
self._usage_reporter = usage_reporter
+ async def _provided_memory_policy(self) -> Any:
+ if self._memory_policy_provider is None:
+ return None
+ provided = self._memory_policy_provider()
+ return await provided if inspect.isawaitable(provided) else provided
+
async def load(self):
"""Load session data from storage."""
if self._loaded:
@@ -1852,9 +1883,15 @@ class Session:
if turn_mode and effective_token_budget <= 0:
raise ValueError("retained_message_token_budget must be greater than 0")
in_memory_default_memory_policy = self._meta.memory_policy
- effective_policy = MemoryPolicy.from_dict(
- memory_policy if memory_policy is not None else self._meta.memory_policy
- )
+ initial_policy = memory_policy
+ memory_policy_source = "commit"
+ if initial_policy is None:
+ initial_policy = self._meta.memory_policy
+ memory_policy_source = "session"
+ if initial_policy is None:
+ initial_policy = await self._provided_memory_policy()
+ memory_policy_source = "user" if initial_policy is not None else "default"
+ effective_policy = MemoryPolicy.from_dict(initial_policy)
_validate_memory_policy_types(effective_policy)
agent_evolution_enabled = self._agent_evolution_enabled
if self._agent_evolution_enabled_provider is not None:
@@ -1869,10 +1906,9 @@ class Session:
agent_evolution_enabled=agent_evolution_enabled,
)
effective_memory_policy = effective_policy.to_dict()
- effective_memory_types = sorted(_effective_memory_types(effective_policy))
agent_memory_skip_reason = _agent_memory_skip_reason(
agent_evolution_enabled=agent_evolution_enabled,
- effective_memory_types=set(effective_memory_types),
+ effective_memory_types=_effective_self_memory_types(effective_policy),
)
logger.info(
f"[TRACER] session_commit started, trace_id={trace_id}, "
@@ -1930,17 +1966,21 @@ class Session:
# messages being archived, unless this commit supplied an explicit
# override.
if memory_policy is None:
- effective_policy = MemoryPolicy.from_dict(self._meta.memory_policy)
+ resolved_policy = self._meta.memory_policy
+ memory_policy_source = "session"
+ if resolved_policy is None:
+ resolved_policy = await self._provided_memory_policy()
+ memory_policy_source = "user" if resolved_policy is not None else "default"
+ effective_policy = MemoryPolicy.from_dict(resolved_policy)
_validate_memory_policy_types(effective_policy)
effective_policy = _apply_agent_evolution_setting(
effective_policy,
agent_evolution_enabled=agent_evolution_enabled,
)
effective_memory_policy = effective_policy.to_dict()
- effective_memory_types = sorted(_effective_memory_types(effective_policy))
agent_memory_skip_reason = _agent_memory_skip_reason(
agent_evolution_enabled=agent_evolution_enabled,
- effective_memory_types=set(effective_memory_types),
+ effective_memory_types=_effective_self_memory_types(effective_policy),
)
self._compression.compression_index = max(
@@ -2045,6 +2085,7 @@ class Session:
archive_uri=archive_uri,
user=self.ctx.user.to_dict(),
memory_policy=effective_memory_policy,
+ memory_policy_source=memory_policy_source,
usage_uris=list(dict.fromkeys(u.uri for u in usage_snapshot if u.uri)),
record_auto_commit_success=record_auto_commit_success,
event_search_tags=list(effective_event_tags),
@@ -2309,7 +2350,8 @@ class Session:
usage_records=[Usage(uri=uri, type="context") for uri in msg.usage_uris],
first_message_id=archive_messages[0].id,
last_message_id=archive_messages[-1].id,
- memory_policy=msg.memory_policy,
+ memory_policy=queued_policy.to_dict(),
+ memory_policy_source=msg.memory_policy_source,
agent_evolution_enabled=agent_evolution_enabled,
agent_memory_skip_reason=agent_memory_skip_reason,
user_config_error=user_config_error,
@@ -2350,6 +2392,7 @@ class Session:
first_message_id: str,
last_message_id: str,
memory_policy: Optional[Dict[str, Any]],
+ memory_policy_source: str = "unknown",
agent_evolution_enabled: bool = True,
agent_memory_skip_reason: Optional[str] = None,
user_config_error: Optional[str] = None,
@@ -2552,6 +2595,8 @@ class Session:
)
self_memory_enabled = extraction_scope.allow_self_memory
allowed_peer_ids = extraction_scope.allowed_peer_ids
+ self_long_term_memory_types = extraction_scope.self_memory_types
+ peer_long_term_memory_types = extraction_scope.peer_memory_types
long_term_memory_types = extraction_scope.memory_types
long_term_messages = [
@@ -2596,6 +2641,8 @@ class Session:
latest_archive_overview=latest_archive_overview,
archive_uri=archive_uri,
allowed_memory_types=long_term_memory_types,
+ allowed_self_memory_types=self_long_term_memory_types,
+ allowed_peer_memory_types=peer_long_term_memory_types,
agent_evolution_enabled=agent_evolution_enabled,
allow_self_memory=self_memory_enabled,
allowed_peer_ids=allowed_peer_ids,
@@ -2769,6 +2816,8 @@ class Session:
"effective_memory_types": sorted(
_effective_memory_types(MemoryPolicy.from_dict(memory_policy))
),
+ "effective_memory_policy": MemoryPolicy.from_dict(memory_policy).to_dict(),
+ "memory_policy_source": memory_policy_source,
"agent_evolution_enabled": agent_evolution_enabled,
"agent_memory_skip_reason": agent_memory_skip_reason,
"token_usage": {
diff --git a/openviking/storage/queuefs/session_commit_msg.py b/openviking/storage/queuefs/session_commit_msg.py
index b4ab6170f..820d56fc9 100644
--- a/openviking/storage/queuefs/session_commit_msg.py
+++ b/openviking/storage/queuefs/session_commit_msg.py
@@ -14,6 +14,7 @@ class SessionCommitMsg:
archive_uri: str
user: Dict[str, str]
memory_policy: Dict[str, Any] = field(default_factory=dict)
+ memory_policy_source: str = "unknown"
usage_uris: List[str] = field(default_factory=list)
# When True, Phase 2's final meta merge also clears the auto-commit error
# fields and stamps last_auto_commit_at. Defaults keep old producers working.
diff --git a/tests/server/test_admin_api.py b/tests/server/test_admin_api.py
index 82b378ab5..873d72999 100644
--- a/tests/server/test_admin_api.py
+++ b/tests/server/test_admin_api.py
@@ -22,7 +22,11 @@ from openviking.server.config import ServerConfig
from openviking.server.dependencies import set_service
from openviking.server.identity import RequestContext, Role
from openviking.server.models import ERROR_CODE_TO_HTTP_STATUS, ErrorInfo, Response
-from openviking.server.user_config import read_user_add_targets, read_user_config
+from openviking.server.user_config import (
+ read_user_add_targets,
+ read_user_config,
+ user_config_backup_uri,
+)
from openviking.service.core import OpenVikingService
from openviking.service.task_store import (
SYSTEM_TASK_ACCOUNT_ID,
@@ -82,6 +86,7 @@ class _FakeVikingFS:
def __init__(self):
self.agfs = _FakeAGFS()
self.files = {}
+ self.writes = []
async def read_file(self, uri, **_kwargs):
if uri not in self.files:
@@ -89,6 +94,7 @@ class _FakeVikingFS:
return self.files[uri]
async def write_file(self, uri, content, **_kwargs):
+ self.writes.append(uri)
self.files[uri] = content
async def rm(self, uri, **_kwargs):
@@ -98,6 +104,11 @@ class _FakeVikingFS:
class _FakeService:
def __init__(self):
self.viking_fs = _FakeVikingFS()
+ self.sessions = self
+
+ async def get_agent_evolution_enabled(self, account_id):
+ del account_id
+ return True
async def initialize_account_directories(self, ctx):
return None
@@ -324,6 +335,84 @@ async def test_create_user_paths_accept_initial_user_config(
assert bob_settings.resource_uri == "viking://user/resources/bob"
+async def test_user_memory_policy_can_be_initialized_and_hot_updated(
+ lightweight_admin_client: httpx.AsyncClient,
+ lightweight_admin_app: FastAPI,
+):
+ acct = _uid()
+ create_account = await lightweight_admin_client.post(
+ "/api/v1/admin/accounts",
+ json={"account_id": acct, "admin_user_id": "alice"},
+ headers=root_headers(),
+ )
+ assert create_account.status_code == 200, create_account.text
+
+ create_user = await lightweight_admin_client.post(
+ f"/api/v1/admin/accounts/{acct}/users",
+ json={
+ "user_id": "bob",
+ "role": "user",
+ "user_config": {
+ "memory_policy": {
+ "self": {"enabled": True, "memory_types": ["profile"]},
+ "peer": {"enabled": False, "memory_types": []},
+ }
+ },
+ },
+ headers=root_headers(),
+ )
+ assert create_user.status_code == 200, create_user.text
+
+ get_settings = await lightweight_admin_client.get(
+ f"/api/v1/admin/accounts/{acct}/users/bob/settings",
+ headers=root_headers(),
+ )
+ assert get_settings.status_code == 200, get_settings.text
+ assert get_settings.json()["result"]["memory_policy"]["self"] == {
+ "enabled": True,
+ "memory_types": ["profile"],
+ }
+
+ patch_settings = await lightweight_admin_client.patch(
+ f"/api/v1/admin/accounts/{acct}/users/bob/settings",
+ json={
+ "memory_policy": {
+ "self": {"enabled": True, "memory_types": ["experiences"]},
+ "peer": {"enabled": True, "memory_types": ["events"]},
+ }
+ },
+ headers=root_headers(),
+ )
+ assert patch_settings.status_code == 200, patch_settings.text
+ memory_policy = patch_settings.json()["result"]["memory_policy"]
+ assert memory_policy["self"]["memory_types"] == [
+ "cases",
+ "experiences",
+ "trajectories",
+ ]
+ assert memory_policy["peer"]["memory_types"] == ["events"]
+
+ viking_fs = lightweight_admin_app.state.fake_service.viking_fs
+ persisted = await read_user_config(
+ viking_fs,
+ RequestContext(user=UserIdentifier(acct, "bob"), role=Role.USER),
+ )
+ assert persisted.memory_policy["self"]["memory_types"] == ["experiences"]
+ assert persisted.memory_policy["peer"]["memory_types"] == ["events"]
+ user_ctx = RequestContext(user=UserIdentifier(acct, "bob"), role=Role.USER)
+ backup = json.loads(viking_fs.files[user_config_backup_uri(user_ctx)])
+ assert backup["memory_policy"]["self"]["memory_types"] == ["profile"]
+
+ writes_before_noop = len(viking_fs.writes)
+ noop_patch = await lightweight_admin_client.patch(
+ f"/api/v1/admin/accounts/{acct}/users/bob/settings",
+ json={"memory_policy": persisted.memory_policy},
+ headers=root_headers(),
+ )
+ assert noop_patch.status_code == 200, noop_patch.text
+ assert len(viking_fs.writes) == writes_before_noop
+
+
async def test_create_user_paths_ignore_deprecated_agent_evolution_config(
lightweight_admin_client: httpx.AsyncClient,
lightweight_admin_app: FastAPI,
diff --git a/tests/server/test_api_sessions.py b/tests/server/test_api_sessions.py
index f1dd8a246..f5d0cc260 100644
--- a/tests/server/test_api_sessions.py
+++ b/tests/server/test_api_sessions.py
@@ -169,6 +169,47 @@ async def test_get_session(client: httpx.AsyncClient):
assert body["result"]["uri"] == session_uri
+async def test_get_session_preserves_legacy_memory_policy_shape(client: httpx.AsyncClient):
+ create_resp = await client.post(
+ "/api/v1/sessions",
+ json={"memory_policy": {"memory_types": ["profile"]}},
+ )
+ session_id = create_resp.json()["result"]["session_id"]
+
+ resp = await client.get(f"/api/v1/sessions/{session_id}")
+
+ assert resp.status_code == 200
+ assert resp.json()["result"]["memory_policy"] == {
+ "self": {"enabled": True},
+ "peer": {"enabled": True},
+ "memory_types": ["profile"],
+ }
+
+
+async def test_get_session_preserves_disabled_legacy_agent_policy_shape(
+ client: httpx.AsyncClient,
+):
+ create_resp = await client.post(
+ "/api/v1/sessions",
+ json={
+ "memory_policy": {
+ "self": {"enabled": False},
+ "memory_types": ["experiences"],
+ }
+ },
+ )
+ session_id = create_resp.json()["result"]["session_id"]
+
+ resp = await client.get(f"/api/v1/sessions/{session_id}")
+
+ assert resp.status_code == 200
+ assert resp.json()["result"]["memory_policy"] == {
+ "self": {"enabled": False},
+ "peer": {"enabled": True},
+ "memory_types": ["cases", "experiences", "trajectories"],
+ }
+
+
async def test_legacy_session_uri_alias_reads_current_user_session(client: httpx.AsyncClient):
session_id = "legacy-alias-read"
await client.post("/api/v1/sessions", json={"session_id": session_id})
diff --git a/tests/session/test_memory_extraction_scope.py b/tests/session/test_memory_extraction_scope.py
index ded2bcba9..7133c03c8 100644
--- a/tests/session/test_memory_extraction_scope.py
+++ b/tests/session/test_memory_extraction_scope.py
@@ -67,3 +67,50 @@ def test_actor_memory_extraction_scope_still_uses_policy_and_messages():
assert scope.allow_self_memory is True
assert scope.allowed_peer_ids == {"bob"}
assert scope.include_session_skills is True
+
+
+def test_memory_extraction_scope_keeps_self_and_peer_type_filters_separate():
+ scope = _resolve_memory_extraction_scope(
+ _ctx(),
+ MemoryPolicy.from_dict(
+ {
+ "self": {"memory_types": ["profile", "experiences"]},
+ "peer": {"memory_types": ["events"]},
+ }
+ ).resolve(
+ {"cases", "events", "experiences", "profile", "trajectories"},
+ agent_evolution_enabled=True,
+ ),
+ [_message("alice")],
+ config_session_skill_extraction_enabled=True,
+ )
+
+ assert scope.self_memory_types == {
+ "cases",
+ "experiences",
+ "profile",
+ "trajectories",
+ }
+ assert scope.peer_memory_types == {"events"}
+
+
+def test_disabled_peer_types_do_not_expand_the_active_extraction_scope():
+ scope = _resolve_memory_extraction_scope(
+ _ctx(),
+ MemoryPolicy.from_dict(
+ {
+ "self": {"memory_types": ["experiences"]},
+ "peer": {
+ "enabled": False,
+ "memory_types": ["profile", "events"],
+ },
+ }
+ ).resolve(
+ {"cases", "events", "experiences", "profile", "trajectories"},
+ agent_evolution_enabled=True,
+ ),
+ [_message("alice")],
+ config_session_skill_extraction_enabled=True,
+ )
+
+ assert scope.memory_types == {"cases", "experiences", "trajectories"}
diff --git a/tests/session/test_session_commit.py b/tests/session/test_session_commit.py
index 969b8ce55..f780919a7 100644
--- a/tests/session/test_session_commit.py
+++ b/tests/session/test_session_commit.py
@@ -164,7 +164,36 @@ class TestCommit:
session_with_messages._session_compressor.extract_long_term_memories.call_args.kwargs
)
assert call_kwargs["agent_evolution_enabled"] is True
- assert call_kwargs["allowed_memory_types"] is None
+ assert call_kwargs["allowed_memory_types"] == set(
+ task_result["result"]["effective_memory_types"]
+ )
+
+ async def test_commit_reads_latest_user_memory_policy_when_session_has_no_override(
+ self, session_with_messages: Session
+ ):
+ session_with_messages._memory_policy_provider = lambda: {
+ "self": {"enabled": True, "memory_types": ["profile"]},
+ "peer": {"enabled": False, "memory_types": []},
+ }
+ session_with_messages._session_compressor.extract_long_term_memories = AsyncMock(
+ return_value=[]
+ )
+
+ result = await session_with_messages.commit_async()
+ task_result = await _wait_for_task(result["task_id"])
+
+ assert task_result["status"] == "completed"
+ assert task_result["result"]["memory_policy_source"] == "user"
+ assert task_result["result"]["effective_memory_policy"] == {
+ "self": {"enabled": True, "memory_types": ["profile"]},
+ "peer": {"enabled": False, "memory_types": []},
+ }
+ call_kwargs = (
+ session_with_messages._session_compressor.extract_long_term_memories.call_args.kwargs
+ )
+ assert call_kwargs["allowed_self_memory_types"] == {"profile"}
+ assert call_kwargs["allowed_peer_memory_types"] == set()
+ assert call_kwargs["allowed_peer_ids"] == set()
async def test_disabled_agent_evolution_keeps_working_memory(
self, session_with_messages: Session, monkeypatch
@@ -228,7 +257,9 @@ class TestCommit:
call_kwargs = (
session_with_messages._session_compressor.extract_long_term_memories.call_args.kwargs
)
- assert call_kwargs["allowed_memory_types"] is None
+ assert call_kwargs["allowed_memory_types"] == set(
+ task_result["result"]["effective_memory_types"]
+ )
async def test_commit_skips_session_skills_without_execution_memory_type(
self, session_with_messages: Session, monkeypatch
diff --git a/tests/session/test_session_retention_integration.py b/tests/session/test_session_retention_integration.py
index 0979be0d2..a40b4b39f 100644
--- a/tests/session/test_session_retention_integration.py
+++ b/tests/session/test_session_retention_integration.py
@@ -1860,10 +1860,11 @@ async def test_stale_worker_uses_lock_snapshot_memory_policy_for_queue_message(
assert result["archived"] is True
queued_policy = queued[0]["memory_policy"]
- assert {
- key: queued_policy[key] for key in updater.meta.memory_policy
- } == updater.meta.memory_policy
- assert set(queued_policy["memory_types"]).isdisjoint(AGENT_EVOLUTION_MEMORY_TYPES)
+ assert queued_policy["working_memory"] == {"enabled": False}
+ assert queued_policy["self"]["enabled"] is False
+ assert queued_policy["peer"]["enabled"] is False
+ assert set(queued_policy["self"]["memory_types"]).isdisjoint(AGENT_EVOLUTION_MEMORY_TYPES)
+ assert queued[0]["memory_policy_source"] == "session"
assert "agent_evolution_enabled" not in queued[0]
archive_meta = json.loads(
await stale_session._viking_fs.read_file(
diff --git a/tests/unit/session/test_memory_policy.py b/tests/unit/session/test_memory_policy.py
index ca1a8fb7e..85cf786ec 100644
--- a/tests/unit/session/test_memory_policy.py
+++ b/tests/unit/session/test_memory_policy.py
@@ -11,6 +11,7 @@ from openviking.session.memory.dataclass import MemoryField, MemoryTypeSchema
from openviking.session.memory.memory_type_registry import MemoryTypeRegistry
from openviking.session.memory.merge_op.base import FieldType
from openviking.session.memory_policy import MemoryPolicy
+from openviking.session.session import _effective_memory_types, _effective_self_memory_types
from openviking_cli.exceptions import InvalidArgumentError
@@ -30,6 +31,18 @@ def test_memory_policy_can_disable_peer_memory():
assert policy.peer_enabled is False
+def test_effective_memory_types_respect_disabled_targets():
+ policy = MemoryPolicy.from_dict(
+ {
+ "self": {"enabled": False, "memory_types": ["experiences"]},
+ "peer": {"enabled": False, "memory_types": ["profile"]},
+ }
+ )
+
+ assert _effective_self_memory_types(policy) == set()
+ assert _effective_memory_types(policy) == set()
+
+
def test_memory_policy_uses_top_level_memory_types():
policy = MemoryPolicy.from_dict(
{
@@ -43,12 +56,31 @@ def test_memory_policy_uses_top_level_memory_types():
assert policy.peer_enabled is True
assert policy.memory_types == {"profile", "events"}
assert policy.to_dict() == {
+ "self": {"enabled": False, "memory_types": ["events", "profile"]},
+ "peer": {"enabled": True, "memory_types": ["events", "profile"]},
+ }
+ assert policy.to_legacy_dict() == {
"self": {"enabled": False},
"peer": {"enabled": True},
"memory_types": ["events", "profile"],
}
+def test_memory_policy_legacy_serialization_preserves_types_when_self_is_disabled():
+ policy = MemoryPolicy.from_dict(
+ {
+ "self": {"enabled": False},
+ "memory_types": ["experiences"],
+ }
+ )
+
+ assert policy.to_legacy_dict() == {
+ "self": {"enabled": False},
+ "peer": {"enabled": True},
+ "memory_types": ["cases", "experiences", "trajectories"],
+ }
+
+
def test_memory_policy_can_disable_working_memory():
policy = MemoryPolicy.from_dict({"working_memory": {"enabled": False}})
@@ -95,6 +127,32 @@ def test_memory_policy_rejects_invalid_memory_types():
with pytest.raises(InvalidArgumentError, match="missing"):
policy.validate_memory_types({"profile"})
+ policy = MemoryPolicy.from_dict({"self": {"enabled": True, "memory_types": ["experiences"]}})
+ assert policy.self_memory_types == {"experiences"}
+ assert policy.resolve(
+ {"cases", "events", "experiences", "profile", "trajectories"},
+ agent_evolution_enabled=True,
+ ).self_memory_types == {"cases", "experiences", "trajectories"}
+
+
+def test_memory_policy_supports_independent_self_and_peer_types():
+ policy = MemoryPolicy.from_dict(
+ {
+ "self": {"enabled": True, "memory_types": ["profile", "experiences"]},
+ "peer": {"enabled": True, "memory_types": ["events"]},
+ }
+ )
+
+ assert policy.self_memory_types == {"experiences", "profile"}
+ assert policy.peer_memory_types == {"events"}
+
+
+def test_memory_policy_rejects_agent_types_for_peer_memory():
+ with pytest.raises(InvalidArgumentError, match="does not support agent memory types"):
+ MemoryPolicy.from_dict({"peer": {"enabled": True, "memory_types": ["experiences"]}})
+
+
+def test_memory_policy_legacy_agent_dependencies():
evolution_policy = MemoryPolicy.from_dict({"memory_types": ["profile", "experiences"]})
assert evolution_policy.memory_types == {
"profile",
diff --git a/tests/unit/session/test_session_commit_resume.py b/tests/unit/session/test_session_commit_resume.py
index cdebae0f7..7c0d4bdd9 100644
--- a/tests/unit/session/test_session_commit_resume.py
+++ b/tests/unit/session/test_session_commit_resume.py
@@ -73,7 +73,10 @@ async def test_resume_queued_commit_continues_phase2(monkeypatch):
session_uri=session_uri,
archive_uri=archive_uri,
user={"account_id": "default", "user_id": "default"},
- memory_policy={"memory_types": []},
+ memory_policy={
+ "self": {"enabled": True, "memory_types": ["events"]},
+ "peer": {"enabled": False, "memory_types": []},
+ },
)
try:
@@ -84,6 +87,10 @@ async def test_resume_queued_commit_continues_phase2(monkeypatch):
session._run_memory_extraction.assert_awaited_once()
assert session._run_memory_extraction.await_args.kwargs["task_id"] == "task-1"
assert session._run_memory_extraction.await_args.kwargs["agent_evolution_enabled"] is True
+ assert session._run_memory_extraction.await_args.kwargs["memory_policy"] == {
+ "self": {"enabled": True, "memory_types": ["events"]},
+ "peer": {"enabled": False, "memory_types": []},
+ }
assert [
item.id for item in session._run_memory_extraction.await_args.kwargs["messages"]
] == ["archived"]