Skip to content

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

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

agentafa5aae9a6e0
diff --git a/docs/en/api/01-overview.md b/docs/en/api/01-overview.md
index 0dab5dee4..f2f95f049 100644
--- a/docs/en/api/01-overview.md
+++ b/docs/en/api/01-overview.md
@@ -484,8 +484,6 @@ 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 a2222c627..4f2b1b853 100644
--- a/docs/en/api/05-sessions.md
+++ b/docs/en/api/05-sessions.md
@@ -1405,11 +1405,6 @@ 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 08f76c38d..dc9499ec5 100644
--- a/docs/en/api/08-admin.md
+++ b/docs/en/api/08-admin.md
@@ -117,33 +117,6 @@ 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 970c2dd02..7bb23870a 100644
--- a/docs/zh/api/01-overview.md
+++ b/docs/zh/api/01-overview.md
@@ -479,8 +479,6 @@ 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 78ceb9e24..9ceef9439 100644
--- a/docs/zh/api/05-sessions.md
+++ b/docs/zh/api/05-sessions.md
@@ -1377,10 +1377,6 @@ 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 35a7dfdc3..52967bce0 100644
--- a/docs/zh/api/08-admin.md
+++ b/docs/zh/api/08-admin.md
@@ -115,30 +115,6 @@ 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 501094350..0bdd74889 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 Any, Dict, List, Literal, Optional
+from typing import Dict, List, Literal, Optional
from pydantic import BaseModel, Field, ValidationError, field_validator
@@ -103,7 +103,6 @@ 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,
@@ -111,15 +110,6 @@ 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 aa6ca8c4a..df626ea19 100644
--- a/openviking/server/routers/admin.py
+++ b/openviking/server/routers/admin.py
@@ -25,13 +25,7 @@ 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 (
- read_user_config,
- validate_add_targets,
- validate_user_memory_policy,
- write_user_config,
- write_user_memory_policy,
-)
+from openviking.server.user_config import validate_add_targets, write_user_config
from openviking.service.legacy_migration import LegacyDataMigration
from openviking.service.task_store import (
SYSTEM_TASK_ACCOUNT_ID,
@@ -40,8 +34,6 @@ 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,
@@ -88,12 +80,6 @@ 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
@@ -191,7 +177,7 @@ def _has_add_targets(user_config: UserConfig | None) -> bool:
def _has_initial_user_config(user_config: UserConfig | None) -> bool:
- return bool(_has_add_targets(user_config) or (user_config and user_config.memory_policy))
+ return _has_add_targets(user_config)
def _validate_initial_user_config(
@@ -199,18 +185,15 @@ def _validate_initial_user_config(
user_ctx: RequestContext,
user_config: UserConfig | None,
) -> None:
- if not _has_initial_user_config(user_config):
+ if not _has_add_targets(user_config):
return
if service.viking_fs is None:
raise FailedPreconditionError("OpenViking service is not initialized.")
- 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)
+ validate_add_targets(
+ user_config.add_targets,
+ ctx=user_ctx,
+ viking_fs=service.viking_fs,
+ )
async def _write_initial_user_config(
@@ -223,31 +206,6 @@ 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,
@@ -509,60 +467,6 @@ 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 02380ebff..908d5a858 100644
--- a/openviking/server/user_config.py
+++ b/openviking/server/user_config.py
@@ -33,10 +33,6 @@ 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,
@@ -73,17 +69,6 @@ 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,
*,
@@ -166,33 +151,17 @@ 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(
- user_config_backup_uri(ctx),
- before_content,
+ uri,
+ json.dumps(
+ current.model_dump(exclude_none=True),
+ ensure_ascii=False,
+ sort_keys=True,
+ ),
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
@@ -202,7 +171,6 @@ 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(
@@ -253,30 +221,6 @@ 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 9953572d6..0273a1ba8 100644
--- a/openviking/service/session_service.py
+++ b/openviking/service/session_service.py
@@ -15,7 +15,6 @@ 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,
@@ -201,15 +200,9 @@ 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,
@@ -247,14 +240,7 @@ class SessionService:
policy.validate_memory_types(
set(MemoryTypeRegistry().list_names(include_disabled=False))
)
- 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()
- )
+ session.meta.memory_policy = policy.to_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 22840e3f3..c568d3b86 100644
--- a/openviking/session/compressor_v3.py
+++ b/openviking/session/compressor_v3.py
@@ -359,8 +359,6 @@ 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,
@@ -373,22 +371,12 @@ 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)
- 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,
+ 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(
@@ -399,7 +387,7 @@ class SessionCompressorV3:
archive_uri=archive_uri or "",
strict_extract_errors=strict_extract_errors,
agent_evolution_enabled=agent_evolution_enabled,
- allowed_memory_types=self_types,
+ allowed_memory_types=allowed_memory_types,
)
result = await self._extract_user_memories(
@@ -411,14 +399,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(self_types)
- cases_allowed = self_types is None or _CASES_MEMORY_TYPE in self_types
+ 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
+ )
session_skills_enabled = self._session_skill_extraction_enabled()
if (
agent_evolution_enabled
@@ -612,8 +600,6 @@ 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,
@@ -637,11 +623,7 @@ class SessionCompressorV3:
if allow_self_memory:
await registry.initialize_memory_files(
ctx,
- allowed_memory_types=(
- allowed_self_memory_types
- if allowed_self_memory_types is not None
- else allowed_memory_types
- ),
+ allowed_memory_types=allowed_memory_types,
)
context_provider = SessionExtractContextProvider(
@@ -660,8 +642,6 @@ 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
@@ -702,8 +682,6 @@ 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 180922013..d7ffd2392 100644
--- a/openviking/session/memory/memory_isolation_handler.py
+++ b/openviking/session/memory/memory_isolation_handler.py
@@ -43,8 +43,6 @@ 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
@@ -53,16 +51,6 @@ 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())
@@ -137,23 +125,11 @@ class MemoryIsolationHandler:
memory_type = getattr(memory_type_schema, "memory_type", "")
if memory_type in _INTERNAL_MEMORY_TYPES:
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
- )
+ 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
def _can_write_peer(self, peer_id: str) -> bool:
return self.allow_peer and peer_id in self.allowed_peer_ids
@@ -204,14 +180,9 @@ 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] = []
- memory_type = getattr(memory_type_schema, "memory_type", "")
- if self.allow_self and self._allows_self_type(memory_type):
+ if self.allow_self:
user_spaces.append(user_space)
- if (
- self.allow_peer
- and getattr(memory_type_schema, "peer_enabled", True)
- and self._allows_peer_type(memory_type)
- ):
+ if self.allow_peer and getattr(memory_type_schema, "peer_enabled", True):
for peer_id in sorted(self.allowed_peer_ids):
user_spaces.append(peer_user_space(user_space, peer_id))
@@ -276,15 +247,12 @@ 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 and self._allows_self_type(memory_type) else []
- )
+ target_ids = [_SELF_PEER_ID] if self.allow_self else []
elif operation.memory_fields.get("ranges") is not None:
target_ids, can_fallback = self._range_targets(
operation.memory_fields.get("ranges"),
@@ -295,11 +263,9 @@ class MemoryIsolationHandler:
target_ids = [fallback_target]
operation.memory_fields.pop("peer_id", None)
else:
- 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)
+ target_id = self._resolve_operation_target_id(
+ operation.memory_fields.get("peer_id"),
+ )
if target_id:
target_ids = [target_id]
if target_id == _SELF_PEER_ID:
@@ -312,15 +278,6 @@ 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 67153a72b..05c6e087b 100644
--- a/openviking/session/memory/streaming_memory_updater.py
+++ b/openviking/session/memory/streaming_memory_updater.py
@@ -1836,8 +1836,6 @@ 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 71a375cb2..a56ffec76 100644
--- a/openviking/session/memory_policy.py
+++ b/openviking/session/memory_policy.py
@@ -15,14 +15,10 @@ from openviking.session.memory.constants import (
from openviking_cli.exceptions import InvalidArgumentError
_POLICY_KEYS = {"self", "peer", "memory_types", "working_memory"}
-_TARGET_KEYS = {"enabled", "memory_types"}
-_WORKING_MEMORY_KEYS = {"enabled"}
+_TARGET_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":
@@ -33,7 +29,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, memory_types"
+ return "memory_policy target supports only: enabled"
def _parse_enabled(value: Any, *, key: str) -> bool:
@@ -52,78 +48,51 @@ 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 _parse_memory_types(
- data: Any,
- *,
- field: str,
- normalize_agent_dependencies: bool = False,
-) -> Optional[set[str]]:
+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]]:
if data is None:
return None
if not isinstance(data, list):
- raise InvalidArgumentError(f"{field} must be a list")
+ raise InvalidArgumentError("memory_policy.memory_types must be a list")
memory_types = set()
for item in data:
if not isinstance(item, str) or not item:
- raise InvalidArgumentError(f"{field} must contain non-empty strings")
+ raise InvalidArgumentError("memory_policy.memory_types must contain non-empty strings")
memory_types.add(item)
- 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)
+ 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.
-
- ``self`` and ``peer`` have independent type filters. The legacy top-level
- ``memory_types`` input is still accepted and normalized into this shape.
- """
+ """Effective memory policy for one commit."""
self_enabled: bool = True
peer_enabled: bool = True
- self_memory_types: Optional[set[str]] = None
- peer_memory_types: Optional[set[str]] = None
+ 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()
@@ -141,107 +110,31 @@ 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=self_enabled,
- peer_enabled=peer_enabled,
- self_memory_types=self_types,
- peer_memory_types=peer_types,
- working_memory_enabled=working_enabled,
+ 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"
+ ),
)
def validate_memory_types(self, known_memory_types: set[str]) -> None:
- 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 self.memory_types is None:
+ return
+ unknown = self.memory_types - 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.self_memory_types is not None:
- data["memory_types"] = sorted(self.self_memory_types)
+ if self.memory_types is not None:
+ data["memory_types"] = sorted(self.memory_types)
return data
diff --git a/openviking/session/session.py b/openviking/session/session.py
index d3fa58d7d..f395da841 100644
--- a/openviking/session/session.py
+++ b/openviking/session/session.py
@@ -105,6 +105,8 @@ 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())
@@ -113,30 +115,24 @@ def _apply_agent_evolution_setting(
*,
agent_evolution_enabled: bool,
) -> MemoryPolicy:
- return policy.resolve(
- _enabled_memory_types(),
- agent_evolution_enabled=agent_evolution_enabled,
+ 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,
)
-
-
-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.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)
+ if policy.memory_types is None:
+ return _enabled_memory_types()
+ return set(policy.memory_types)
def _agent_memory_skip_reason(
@@ -190,8 +186,6 @@ 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]]
@@ -204,29 +198,12 @@ 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,
- 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,
+ memory_types=policy.memory_types,
)
@@ -618,7 +595,6 @@ 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
@@ -651,15 +627,8 @@ 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:
@@ -1883,15 +1852,9 @@ 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
- 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)
+ effective_policy = MemoryPolicy.from_dict(
+ memory_policy if memory_policy is not None else self._meta.memory_policy
+ )
_validate_memory_policy_types(effective_policy)
agent_evolution_enabled = self._agent_evolution_enabled
if self._agent_evolution_enabled_provider is not None:
@@ -1906,9 +1869,10 @@ 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=_effective_self_memory_types(effective_policy),
+ effective_memory_types=set(effective_memory_types),
)
logger.info(
f"[TRACER] session_commit started, trace_id={trace_id}, "
@@ -1966,21 +1930,17 @@ class Session:
# messages being archived, unless this commit supplied an explicit
# override.
if memory_policy is None:
- 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)
+ effective_policy = MemoryPolicy.from_dict(self._meta.memory_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=_effective_self_memory_types(effective_policy),
+ effective_memory_types=set(effective_memory_types),
)
self._compression.compression_index = max(
@@ -2085,7 +2045,6 @@ 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),
@@ -2350,8 +2309,7 @@ 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=queued_policy.to_dict(),
- memory_policy_source=msg.memory_policy_source,
+ memory_policy=msg.memory_policy,
agent_evolution_enabled=agent_evolution_enabled,
agent_memory_skip_reason=agent_memory_skip_reason,
user_config_error=user_config_error,
@@ -2392,7 +2350,6 @@ 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,
@@ -2595,8 +2552,6 @@ 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 = [
@@ -2641,8 +2596,6 @@ 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,
@@ -2816,8 +2769,6 @@ 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 820d56fc9..b4ab6170f 100644
--- a/openviking/storage/queuefs/session_commit_msg.py
+++ b/openviking/storage/queuefs/session_commit_msg.py
@@ -14,7 +14,6 @@ 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 873d72999..82b378ab5 100644
--- a/tests/server/test_admin_api.py
+++ b/tests/server/test_admin_api.py
@@ -22,11 +22,7 @@ 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,
- user_config_backup_uri,
-)
+from openviking.server.user_config import read_user_add_targets, read_user_config
from openviking.service.core import OpenVikingService
from openviking.service.task_store import (
SYSTEM_TASK_ACCOUNT_ID,
@@ -86,7 +82,6 @@ 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:
@@ -94,7 +89,6 @@ 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):
@@ -104,11 +98,6 @@ 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
@@ -335,84 +324,6 @@ 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 f5d0cc260..f1dd8a246 100644
--- a/tests/server/test_api_sessions.py
+++ b/tests/server/test_api_sessions.py
@@ -169,47 +169,6 @@ 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 7133c03c8..ded2bcba9 100644
--- a/tests/session/test_memory_extraction_scope.py
+++ b/tests/session/test_memory_extraction_scope.py
@@ -67,50 +67,3 @@ 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 f780919a7..969b8ce55 100644
--- a/tests/session/test_session_commit.py
+++ b/tests/session/test_session_commit.py
@@ -164,36 +164,7 @@ 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"] == 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()
+ assert call_kwargs["allowed_memory_types"] is None
async def test_disabled_agent_evolution_keeps_working_memory(
self, session_with_messages: Session, monkeypatch
@@ -257,9 +228,7 @@ class TestCommit:
call_kwargs = (
session_with_messages._session_compressor.extract_long_term_memories.call_args.kwargs
)
- assert call_kwargs["allowed_memory_types"] == set(
- task_result["result"]["effective_memory_types"]
- )
+ assert call_kwargs["allowed_memory_types"] is None
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 a40b4b39f..0979be0d2 100644
--- a/tests/session/test_session_retention_integration.py
+++ b/tests/session/test_session_retention_integration.py
@@ -1860,11 +1860,10 @@ 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 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 {
+ 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 "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 85cf786ec..ca1a8fb7e 100644
--- a/tests/unit/session/test_memory_policy.py
+++ b/tests/unit/session/test_memory_policy.py
@@ -11,7 +11,6 @@ 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
@@ -31,18 +30,6 @@ 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(
{
@@ -56,31 +43,12 @@ 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}})
@@ -127,32 +95,6 @@ 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 7c0d4bdd9..cdebae0f7 100644
--- a/tests/unit/session/test_session_commit_resume.py
+++ b/tests/unit/session/test_session_commit_resume.py
@@ -73,10 +73,7 @@ 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={
- "self": {"enabled": True, "memory_types": ["events"]},
- "peer": {"enabled": False, "memory_types": []},
- },
+ memory_policy={"memory_types": []},
)
try:
@@ -87,10 +84,6 @@ 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"]