Skip to content

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

fix(session): apply memory type policy whitelist (#2530)

Qin Haojiea6fc0424bc63
diff --git a/benchmark/locomo/vikingbot/import_to_ov.py b/benchmark/locomo/vikingbot/import_to_ov.py
index 3b8bcb410..4f925c50b 100644
--- a/benchmark/locomo/vikingbot/import_to_ov.py
+++ b/benchmark/locomo/vikingbot/import_to_ov.py
@@ -31,7 +31,7 @@ def _get_session_number(session_key: str) -> int:
def build_memory_policy(group_chat: bool) -> Dict[str, Dict[str, bool]]:
- """Build session/commit memory policy for benchmark ingest."""
+ """Build session memory policy for benchmark ingest."""
return {
"self": {"enabled": True},
"peer": {"enabled": bool(group_chat)},
@@ -365,11 +365,7 @@ async def viking_ingest(
)
# Commit
- result = await client.commit_session(
- session_id,
- telemetry=True,
- memory_policy=memory_policy,
- )
+ result = await client.commit_session(session_id, telemetry=True)
# Accept both "committed" and "accepted" as success - accepted means the session was archived
if result.get("status") not in ("committed", "accepted"):
diff --git a/bot/README.md b/bot/README.md
index ca91a0e5f..e79bc7048 100644
--- a/bot/README.md
+++ b/bot/README.md
@@ -181,7 +181,7 @@ All configurations are under the `bot` field in `ov.conf`, with default values f
- `root_api_key`: API key used by the bot when calling the OpenViking server. Despite the historical field name, this field is also used in the `user` key flow.
- `account_id`: Defaults to `default`, which is the OpenViking account ID. All users under the same OpenViking account share resources.
- `api_key_type`: Optional `root` or `user`, default `root`. `root` keeps the original root-key fanout behavior; `user` switches the bot to the user-key flow for OpenViking client calls. For a hosted remote OpenViking service, `user` is usually the recommended choice.
- - exp_write_tools: Optional list of tool names that trigger experience-memory injection before the call (self-evolving agent memory loop, see #2007). Defaults to `["write_file", "edit_file"]`. Injection only fires when the OpenViking server has `memory.agent_memory_enabled` set; otherwise this list is harmless.
+ - exp_write_tools: Optional list of tool names that trigger experience-memory injection before the call (self-evolving agent memory loop, see #2007). Defaults to `["write_file", "edit_file"]`. This only controls the bot-side injection trigger; stored experience generation is governed by OpenViking memory extraction and the active session `memory_policy.memory_types` whitelist.
- `recall_exp_first_round_only`: Optional. When `true`, `ContextBuilder._build_user_memory` skips per-turn user/agent experience recall and injects experiences only once on the first user turn. Defaults to `false`.
- `exp_recall_limit`: Optional. Number of experiences to retrieve per task during recall. Defaults to `5`.
- `exp_recall_max_chars`: Optional. Character budget for the formatted experience block injected into context. Defaults to `2000`.
diff --git a/bot/README_CN.md b/bot/README_CN.md
index 232177c10..313654e4b 100644
--- a/bot/README_CN.md
+++ b/bot/README_CN.md
@@ -184,7 +184,7 @@ bot 将连接到远程 OpenViking Server,使用前请先启动 OpenViking Serv
- `root_api_key`:bot 调用 OpenViking Server 时使用的 API Key。尽管字段名保留为 `root_api_key`,但在 `user` key 流程下该字段同样会被使用。
- `account_id`:默认值为 `default`,即 OpenViking 的账号 ID。同一 OpenViking account 下的所有 user 共享 resources。
- `api_key_type`:可选 `root` 或 `user`,默认 `root`。`root` 保留原有的 root-key fanout 行为;`user` 切换 bot 走 user-key 流程调用 OpenViking 客户端。对于托管型远端 OpenViking 服务,通常推荐使用 `user`。
- - `exp_write_tools`:可选,触发经验记忆注入的工具名列表(自演化 agent memory 循环,详见 #2007)。默认 `["write_file", "edit_file"]`。注入仅在 OpenViking Server 启用 `memory.agent_memory_enabled` 时生效,否则此列表无作用。
+ - `exp_write_tools`:可选,触发经验记忆注入的工具名列表(自演化 agent memory 循环,详见 #2007)。默认 `["write_file", "edit_file"]`。该配置只控制 bot 侧注入触发时机;已存储 experience 的生成由 OpenViking 记忆抽取和当前 session 的 `memory_policy.memory_types` 白名单控制。
- `recall_exp_first_round_only`:可选。为 `true` 时,`ContextBuilder._build_user_memory` 跳过每轮 user/agent 经验召回,仅在首个 user turn 注入一次经验。默认 `false`。
- `exp_recall_limit`:可选。召回时每个任务检索的经验条数。默认 `5`。
- `exp_recall_max_chars`:可选。注入到上下文的格式化经验块的字符预算。默认 `2000`。
diff --git a/docs/design/session-memory-extraction-flow.md b/docs/design/session-memory-extraction-flow.md
index df1427f71..5323704c0 100644
--- a/docs/design/session-memory-extraction-flow.md
+++ b/docs/design/session-memory-extraction-flow.md
@@ -5,45 +5,51 @@ code-modification reference, so it avoids proposed or removed flows.
## Policy
-`memory_policy` only carries target switches:
+`memory_policy` carries target switches plus an optional global memory type
+whitelist:
```json
{
"self": { "enabled": true },
- "peer": { "enabled": false }
+ "peer": { "enabled": false },
+ "memory_types": ["profile", "preferences"]
}
```
-Legacy `types` fields are ignored. Type selection is not controlled by
-`memory_policy`.
+When `memory_types` is omitted or `null`, all enabled schemas from
+`MemoryTypeRegistry` are allowed, including custom prompt/schema types. When it
+is set, extraction is limited to those names for both self and peer writes.
## Memory Type Groups
| Group | Types | Target |
| --- | --- | --- |
-| Long-term memory | `profile`, `preferences`, `entities`, `events`, `cases`, `patterns`, `tools`, `skills`, `identity`, `soul` | Self and peer |
-| Agent memory | `trajectories`, `experiences` | Self only |
+| Long-term memory extraction | Enabled registry schemas without `agent_only` | Self and peer |
+| Execution memory extraction | Execution-derived schemas, currently `trajectories`, `experiences` | Self only |
| Session skills | `SESSION_SKILL_MEMORY_TYPE` output | Self only |
-Agent memory is enabled only when `config.memory.agent_memory_enabled` is true.
-Session skill extraction also requires self memory to be enabled.
+Trajectory/experience extraction is controlled by `memory_types`: omitted or
+`null` allows both, while an explicit list must include those names. Session
+skill extraction also requires self memory to be enabled and only runs when the
+execution memory extraction phase has work.
## Commit Flow
Implemented in `openviking/session/session.py`:
-1. Merge session-level and commit-level policy with `MemoryPolicy.merge`.
+1. Load the session-level policy from session metadata.
2. Archive the current message batch.
3. Hydrate tool outputs for extraction.
4. If peer memory is enabled, collect safe `message.peer_id` values from the
archived batch into `allowed_peer_ids`.
5. Start archive summary generation.
-6. If long-term extraction is enabled, call
+6. If long-term memory extraction is enabled and allowed by `memory_types`, call
`SessionCompressorV2.extract_long_term_memories` once with the full archived
batch, `allow_self_memory`, and `allowed_peer_ids`.
-7. If self agent extraction is enabled, call
- `SessionCompressorV2.extract_agent_memories` once with the full archived
- batch.
+7. If trajectory/experience extraction has work, call
+ `SessionCompressorV2.extract_execution_memories` once with the full archived
+ batch. When session skill extraction is enabled, it runs inside this execution
+ phase instead of starting a separate phase by itself.
The current flow does not build separate buckets such as
`self_identity_messages`, `self_experience_messages`,
diff --git a/docs/en/api/05-sessions.md b/docs/en/api/05-sessions.md
index ab257e181..72bc15add 100644
--- a/docs/en/api/05-sessions.md
+++ b/docs/en/api/05-sessions.md
@@ -32,7 +32,7 @@ Create a new session. Sessions are containers for conversations, storing message
| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| session_id | str | No | None | Session ID. Creates new session with auto-generated ID if None |
-| memory_policy | object | No | None | Default self/peer memory-extraction policy for the session. An object with optional `self` and `peer` keys, each `{"enabled": <bool>}` (defaults: `self.enabled=true`, `peer.enabled=false`). Overridable per commit; a non-object value is rejected with `InvalidArgumentError`. |
+| memory_policy | object | No | None | Default memory extraction policy for the session. Optional `self` and `peer` switches control write targets, and optional top-level `memory_types` limits extraction to specific enabled memory schemas. When `memory_types` is omitted or `null`, all enabled memory schemas are allowed. Invalid shapes or unknown memory types are rejected with `InvalidArgumentError`. |
#### 3. Usage Examples
@@ -910,7 +910,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. |
-| memory_policy | object | No | None | Controls whether self-memory and peer-memory extraction run on this commit. An object with optional `self` and `peer` keys, each `{"enabled": <bool>}` (defaults: `self.enabled=true`, `peer.enabled=false`). A commit-level value overrides the session-level policy; a non-object value is rejected with `InvalidArgumentError`. |
#### 3. Usage Examples
@@ -926,12 +925,6 @@ curl -X POST http://localhost:1933/api/v1/sessions/a1b2c3d4/commit \
-H "Content-Type: application/json" \
-H "X-API-Key: your-key"
-# Commit and additionally run peer-memory extraction (off by default)
-curl -X POST http://localhost:1933/api/v1/sessions/a1b2c3d4/commit \
- -H "Content-Type: application/json" \
- -H "X-API-Key: your-key" \
- -d '{"memory_policy": {"peer": {"enabled": true}}}'
-
# Poll task status
curl -X GET http://localhost:1933/api/v1/tasks/{task_id} \
-H "X-API-Key: your-key"
diff --git a/docs/en/guides/01-configuration.md b/docs/en/guides/01-configuration.md
index 92b535afa..cc6fd0e4c 100644
--- a/docs/en/guides/01-configuration.md
+++ b/docs/en/guides/01-configuration.md
@@ -1269,8 +1269,7 @@ For memory-related settings, add a `memory` section in `ov.conf`:
```json
{
"memory": {
- "version": "v2",
- "agent_memory_enabled": false
+ "version": "v2"
}
}
```
@@ -1278,7 +1277,6 @@ For memory-related settings, add a `memory` section in `ov.conf`:
| Field | Description | Default |
|-------|-------------|---------|
| `version` | Memory implementation version. Only `"v2"` is supported (legacy `"v1"` removed in #2264 — passing `"v1"` now raises a `ValueError` at config load). | `"v2"` |
-| `agent_memory_enabled` | Enables trajectory/experience memory extraction after user-memory extraction. | `false` |
### ovcli.conf
diff --git a/docs/zh/api/05-sessions.md b/docs/zh/api/05-sessions.md
index 46b644e0c..f70593026 100644
--- a/docs/zh/api/05-sessions.md
+++ b/docs/zh/api/05-sessions.md
@@ -32,7 +32,7 @@
| 参数 | 类型 | 必填 | 默认值 | 说明 |
|------|------|------|--------|------|
| session_id | str | 否 | None | 会话 ID。如果为 None,则创建一个自动生成 ID 的新会话 |
-| memory_policy | object | 否 | None | 会话默认的自我/对方记忆抽取策略。对象,包含可选的 `self` 和 `peer` 键,每个为 `{"enabled": <bool>}`(默认:`self.enabled=true`、`peer.enabled=false`)。可在 commit 时覆盖;非对象值会以 `InvalidArgumentError` 拒绝。 |
+| memory_policy | object | 否 | None | 会话默认的记忆抽取策略。可选的 `self` 和 `peer` 开关控制写入目标;可选的顶层 `memory_types` 将抽取限制为指定的 enabled memory schema。未传或为 `null` 时允许所有 enabled memory schema。非法结构或未知 memory type 会以 `InvalidArgumentError` 拒绝。 |
#### 3. 使用示例
@@ -910,7 +910,6 @@ await client.session_used(
|------|------|------|--------|------|
| session_id | str | 是 | - | 要提交的会话 ID |
| keep_recent_count | int | 否 | 0 | 提交后保留为 live 状态的最近消息数 (保持 live, 不归档)。`0` (默认) 归档全部消息。 |
-| memory_policy | object | 否 | None | 控制本次 commit 是否运行自我记忆与对方记忆抽取。对象,包含可选的 `self` 和 `peer` 键,每个为 `{"enabled": <bool>}`(默认:`self.enabled=true`、`peer.enabled=false`)。commit 级的值会覆盖会话级策略;非对象值会以 `InvalidArgumentError` 拒绝。 |
#### 3. 使用示例
@@ -926,12 +925,6 @@ curl -X POST http://localhost:1933/api/v1/sessions/a1b2c3d4/commit \
-H "Content-Type: application/json" \
-H "X-API-Key: your-key"
-# 提交并额外运行对方记忆抽取(默认关闭)
-curl -X POST http://localhost:1933/api/v1/sessions/a1b2c3d4/commit \
- -H "Content-Type: application/json" \
- -H "X-API-Key: your-key" \
- -d '{"memory_policy": {"peer": {"enabled": true}}}'
-
# 查询任务状态
curl -X GET http://localhost:1933/api/v1/tasks/{task_id} \
-H "X-API-Key: your-key"
diff --git a/docs/zh/guides/01-configuration.md b/docs/zh/guides/01-configuration.md
index a5321c3bb..c05c82d7c 100644
--- a/docs/zh/guides/01-configuration.md
+++ b/docs/zh/guides/01-configuration.md
@@ -1242,8 +1242,7 @@ openviking-server --config /path/to/ov.conf
```json
{
"memory": {
- "version": "v2",
- "agent_memory_enabled": false
+ "version": "v2"
}
}
```
@@ -1251,7 +1250,6 @@ openviking-server --config /path/to/ov.conf
| 字段 | 说明 | 默认值 |
|------|------|--------|
| `version` | 记忆实现版本。仅支持 `"v2"`(#2264 已移除旧版 `"v1"`;传入 `"v1"` 会在配置加载时抛出 `ValueError`)。 | `"v2"` |
-| `agent_memory_enabled` | 在用户记忆抽取之后启用 trajectory/experience 记忆抽取。 | `false` |
### ovcli.conf
diff --git a/examples/openclaw-plugin/client.ts b/examples/openclaw-plugin/client.ts
index 98961e4ba..af5364c7b 100644
--- a/examples/openclaw-plugin/client.ts
+++ b/examples/openclaw-plugin/client.ts
@@ -49,6 +49,7 @@ export type OVMemoryPolicySwitch = {
export type OVMemoryPolicy = {
self?: OVMemoryPolicySwitch;
peer?: OVMemoryPolicySwitch;
+ memory_types?: string[];
};
export type TaskResult = {
@@ -834,7 +835,6 @@ export class OpenVikingClient {
* preserves the pre-v2 "archive everything" behavior.
*/
keepRecentCount?: number;
- memoryPolicy?: OVMemoryPolicy;
},
): Promise<CommitSessionResult> {
const keepRecentCount =
@@ -855,9 +855,6 @@ export class OpenVikingClient {
if (keepRecentCount > 0) {
body.keep_recent_count = keepRecentCount;
}
- if (options?.memoryPolicy) {
- body.memory_policy = options.memoryPolicy;
- }
const result = await this.request<CommitSessionResult>(
`/api/v1/sessions/${encodeURIComponent(sessionId)}/commit`,
{ method: "POST", body: JSON.stringify(body) },
diff --git a/examples/openclaw-plugin/context-engine.ts b/examples/openclaw-plugin/context-engine.ts
index 352b916ba..c63753373 100644
--- a/examples/openclaw-plugin/context-engine.ts
+++ b/examples/openclaw-plugin/context-engine.ts
@@ -1138,7 +1138,6 @@ export function createMemoryOpenVikingContextEngine(params: {
wait: true,
agentId,
keepRecentCount: 0,
- memoryPolicy: defaultMemoryPolicy,
});
const memCount = totalExtractedMemories(commitResult.memories_extracted);
if (commitResult.status === "failed") {
@@ -1697,7 +1696,6 @@ export function createMemoryOpenVikingContextEngine(params: {
wait: false,
agentId,
keepRecentCount: cfg.commitKeepRecentCount,
- memoryPolicy: defaultMemoryPolicy,
});
logger.info(
`openviking: committed session=${OVSessionId}, ` +
@@ -1795,7 +1793,6 @@ export function createMemoryOpenVikingContextEngine(params: {
wait: true,
agentId,
keepRecentCount: 0,
- memoryPolicy: defaultMemoryPolicy,
});
const memCount = totalExtractedMemories(commitResult.memories_extracted);
diff --git a/examples/openclaw-plugin/index.ts b/examples/openclaw-plugin/index.ts
index dc09dd4ba..5ef1c723e 100644
--- a/examples/openclaw-plugin/index.ts
+++ b/examples/openclaw-plugin/index.ts
@@ -1278,7 +1278,6 @@ const contextEnginePlugin = {
wait: true,
agentId: session.agentId,
keepRecentCount: 0,
- memoryPolicy: defaultMemoryPolicy,
});
const memoriesCount = totalCommitMemories(commitResult);
if (commitResult.status === "failed") {
diff --git a/examples/openclaw-plugin/tests/ut/client.test.ts b/examples/openclaw-plugin/tests/ut/client.test.ts
index 32a3cf460..43f54e68f 100644
--- a/examples/openclaw-plugin/tests/ut/client.test.ts
+++ b/examples/openclaw-plugin/tests/ut/client.test.ts
@@ -355,7 +355,7 @@ describe("OpenVikingClient resource and skill import", () => {
});
});
- it("sends memory_policy when committing a session", async () => {
+ it("does not send memory_policy when committing a session", async () => {
const fetchMock = vi.fn().mockResolvedValue(okResponse({
session_id: "s1",
status: "accepted",
@@ -364,20 +364,10 @@ describe("OpenVikingClient resource and skill import", () => {
vi.stubGlobal("fetch", fetchMock);
const client = new OpenVikingClient("http://127.0.0.1:1933", "", "agent", 5000);
- await client.commitSession("s1", {
- memoryPolicy: {
- self: { enabled: true },
- peer: { enabled: true },
- },
- });
+ await client.commitSession("s1");
const [, init] = fetchMock.mock.calls[0] as [string, RequestInit];
- expect(JSON.parse(String(init.body))).toEqual({
- memory_policy: {
- self: { enabled: true },
- peer: { enabled: true },
- },
- });
+ expect(JSON.parse(String(init.body))).toEqual({});
});
});
diff --git a/examples/openclaw-plugin/tests/ut/context-engine-afterTurn.test.ts b/examples/openclaw-plugin/tests/ut/context-engine-afterTurn.test.ts
index 6a42b9ab3..42138f354 100644
--- a/examples/openclaw-plugin/tests/ut/context-engine-afterTurn.test.ts
+++ b/examples/openclaw-plugin/tests/ut/context-engine-afterTurn.test.ts
@@ -375,11 +375,8 @@ describe("context-engine afterTurn()", () => {
expect(client.commitSession).toHaveBeenCalledTimes(1);
expect(client.commitSession.mock.calls[0][1]).toMatchObject({
wait: false,
- memoryPolicy: {
- self: { enabled: true },
- peer: { enabled: true },
- },
});
+ expect(client.commitSession.mock.calls[0][1]).not.toHaveProperty("memoryPolicy");
});
it("catches errors without throwing", async () => {
diff --git a/examples/openclaw-plugin/tests/ut/context-engine-compact.test.ts b/examples/openclaw-plugin/tests/ut/context-engine-compact.test.ts
index e6ce44ac5..b4cebe671 100644
--- a/examples/openclaw-plugin/tests/ut/context-engine-compact.test.ts
+++ b/examples/openclaw-plugin/tests/ut/context-engine-compact.test.ts
@@ -120,7 +120,7 @@ describe("context-engine commitOVSession()", () => {
expect(client.commitSession.mock.calls[0][1]).toMatchObject({ wait: true });
});
- it("passes peer memory policy when peer_role is person", async () => {
+ it("does not pass memory policy when committing peer-role sessions", async () => {
const { engine, client } = makeEngine(
{
status: "completed",
@@ -134,11 +134,8 @@ describe("context-engine commitOVSession()", () => {
expect(client.commitSession.mock.calls[0][1]).toMatchObject({
wait: true,
- memoryPolicy: {
- self: { enabled: true },
- peer: { enabled: true },
- },
});
+ expect(client.commitSession.mock.calls[0][1]).not.toHaveProperty("memoryPolicy");
});
it("uses sessionKey-derived OV session ID for commitOVSession", async () => {
@@ -328,7 +325,7 @@ describe("context-engine compact()", () => {
expect(client.commitSession.mock.calls[0][1]).toMatchObject({ wait: true });
});
- it("compact passes peer memory policy when peer_role is person", async () => {
+ it("compact does not pass memory policy when committing peer-role sessions", async () => {
const { engine, client } = makeEngine(
{
status: "completed",
@@ -342,11 +339,8 @@ describe("context-engine compact()", () => {
expect(client.commitSession.mock.calls[0][1]).toMatchObject({
wait: true,
- memoryPolicy: {
- self: { enabled: true },
- peer: { enabled: true },
- },
});
+ expect(client.commitSession.mock.calls[0][1]).not.toHaveProperty("memoryPolicy");
});
it("logs memory extraction count on success", async () => {
diff --git a/examples/openclaw-plugin/tests/ut/tools.test.ts b/examples/openclaw-plugin/tests/ut/tools.test.ts
index f9f03d5f6..49517b197 100644
--- a/examples/openclaw-plugin/tests/ut/tools.test.ts
+++ b/examples/openclaw-plugin/tests/ut/tools.test.ts
@@ -413,12 +413,9 @@ describe("Tool: memory_store (behavioral)", () => {
String(url).endsWith("/commit"),
);
expect(commitCall).toBeDefined();
- expect(JSON.parse(String((commitCall![1] as RequestInit).body))).toMatchObject({
- memory_policy: {
- self: { enabled: true },
- peer: { enabled: true },
- },
- });
+ expect(JSON.parse(String((commitCall![1] as RequestInit).body))).not.toHaveProperty(
+ "memory_policy",
+ );
});
it("does not populate peer_id for user writes by default", async () => {
diff --git a/examples/ov.conf.example b/examples/ov.conf.example
index 3388dfb6b..48ad9aa15 100644
--- a/examples/ov.conf.example
+++ b/examples/ov.conf.example
@@ -159,7 +159,6 @@
"version": "v2",
"extraction_enabled": true,
"session_skill_extraction_enabled": false,
- // "agent_memory_enabled": true, // set to false to disable trajectory/experience memory extraction
},
"log": {
"level": "INFO",
diff --git a/openviking/async_client.py b/openviking/async_client.py
index 48a2f00b4..331247583 100644
--- a/openviking/async_client.py
+++ b/openviking/async_client.py
@@ -225,7 +225,6 @@ class AsyncOpenViking:
telemetry: TelemetryRequest = False,
*,
keep_recent_count: int = 0,
- memory_policy: Optional[Dict[str, Any]] = None,
) -> Dict[str, Any]:
"""Commit a session (archive and extract memories)."""
await self._ensure_initialized()
@@ -233,7 +232,6 @@ class AsyncOpenViking:
session_id,
telemetry=telemetry,
keep_recent_count=keep_recent_count,
- memory_policy=memory_policy,
)
async def get_task(self, task_id: str) -> Optional[Dict[str, Any]]:
diff --git a/openviking/client/local.py b/openviking/client/local.py
index 2d7744d4f..ca56a7516 100644
--- a/openviking/client/local.py
+++ b/openviking/client/local.py
@@ -483,7 +483,6 @@ class LocalClient(BaseClient):
telemetry: TelemetryRequest = False,
*,
keep_recent_count: int = 0,
- memory_policy: Optional[Dict[str, Any]] = None,
) -> Dict[str, Any]:
"""Commit a session (archive and extract memories)."""
execution = await run_with_telemetry(
@@ -493,7 +492,6 @@ class LocalClient(BaseClient):
session_id,
self._ctx,
keep_recent_count=keep_recent_count,
- memory_policy=memory_policy,
),
)
return attach_telemetry_payload(
diff --git a/openviking/client/session.py b/openviking/client/session.py
index 90956de96..786ddb9d7 100644
--- a/openviking/client/session.py
+++ b/openviking/client/session.py
@@ -97,7 +97,6 @@ class Session:
telemetry: TelemetryRequest = False,
*,
keep_recent_count: int = 0,
- memory_policy: Optional[Dict[str, Any]] = None,
) -> Dict[str, Any]:
"""Commit the session (archive messages and extract memories).
@@ -108,7 +107,6 @@ class Session:
self.session_id,
telemetry=telemetry,
keep_recent_count=keep_recent_count,
- memory_policy=memory_policy,
)
async def commit_async(
@@ -116,7 +114,6 @@ class Session:
telemetry: TelemetryRequest = False,
*,
keep_recent_count: int = 0,
- memory_policy: Optional[Dict[str, Any]] = None,
) -> Dict[str, Any]:
"""Commit the session asynchronously (archive messages and extract memories).
Used in viking bot for committing.
@@ -127,7 +124,6 @@ class Session:
return await self.commit(
telemetry=telemetry,
keep_recent_count=keep_recent_count,
- memory_policy=memory_policy,
)
async def delete(self) -> None:
diff --git a/openviking/server/routers/sessions.py b/openviking/server/routers/sessions.py
index 08ff9f90c..461663b0a 100644
--- a/openviking/server/routers/sessions.py
+++ b/openviking/server/routers/sessions.py
@@ -5,7 +5,7 @@
from typing import Any, Dict, List, Literal, Optional
from fastapi import APIRouter, Body, Depends, Path, Query, Request
-from pydantic import BaseModel, Field, model_validator
+from pydantic import BaseModel, ConfigDict, Field, model_validator
from openviking.core.path_variables import resolve_path_variables
from openviking.core.peer_id import normalize_peer_id
@@ -342,6 +342,8 @@ class CommitRequest(BaseModel):
behavior.
"""
+ model_config = ConfigDict(extra="forbid")
+
keep_recent_count: int = Field(
default=0,
ge=0,
@@ -352,7 +354,6 @@ class CommitRequest(BaseModel):
"(default 10); compact path passes 0 to archive everything."
),
)
- memory_policy: Optional[Dict[str, Any]] = None
telemetry: TelemetryRequest = False
@@ -376,7 +377,6 @@ async def commit_session(
session_id,
_ctx,
keep_recent_count=body.keep_recent_count,
- memory_policy=body.memory_policy,
),
)
return Response(
diff --git a/openviking/service/session_service.py b/openviking/service/session_service.py
index daa5f5e52..d822dd01c 100644
--- a/openviking/service/session_service.py
+++ b/openviking/service/session_service.py
@@ -14,6 +14,7 @@ from openviking.server.config import ToolOutputExternalizationConfig
from openviking.server.identity import RequestContext, Role
from openviking.service.task_tracker import get_task_tracker
from openviking.session import Session, SessionMeta
+from openviking.session.memory.memory_type_registry import MemoryTypeRegistry
from openviking.session.memory_policy import MemoryPolicy
from openviking.storage import VikingDBManager
from openviking.storage.viking_fs import VikingFS
@@ -189,6 +190,9 @@ class SessionService:
session = self.session(ctx, session_id)
if memory_policy is not None:
policy = MemoryPolicy.from_dict(memory_policy)
+ policy.validate_memory_types(
+ set(MemoryTypeRegistry().list_names(include_disabled=False))
+ )
session.meta.memory_policy = policy.to_dict()
await session.ensure_exists()
self._record_lifecycle_metric("create", "ok")
@@ -290,7 +294,6 @@ class SessionService:
session_id: str,
ctx: RequestContext,
keep_recent_count: int = 0,
- memory_policy: Optional[Dict[str, Any]] = None,
) -> Dict[str, Any]:
"""Commit a session (archive messages and extract memories).
@@ -307,7 +310,6 @@ class SessionService:
session_id,
ctx,
keep_recent_count=keep_recent_count,
- memory_policy=memory_policy,
)
async def commit_async(
@@ -315,7 +317,6 @@ class SessionService:
session_id: str,
ctx: RequestContext,
keep_recent_count: int = 0,
- memory_policy: Optional[Dict[str, Any]] = None,
) -> Dict[str, Any]:
"""Async commit a session.
@@ -333,10 +334,7 @@ class SessionService:
"""
self._ensure_initialized()
session = await self.get(session_id, ctx)
- result = await session.commit_async(
- keep_recent_count=keep_recent_count,
- memory_policy=memory_policy,
- )
+ result = await session.commit_async(keep_recent_count=keep_recent_count)
self._record_lifecycle_metric("commit", "ok" if result.get("status") else "error")
self._record_archive_metric("ok" if result.get("archived") else "skip")
return result
diff --git a/openviking/session/compressor_v2.py b/openviking/session/compressor_v2.py
index 193d071e5..596f99b05 100644
--- a/openviking/session/compressor_v2.py
+++ b/openviking/session/compressor_v2.py
@@ -16,6 +16,7 @@ from openviking.core.context import Context
from openviking.message import Message
from openviking.server.identity import RequestContext
from openviking.session.memory import ExtractLoop, MemoryUpdater
+from openviking.session.memory.constants import EXECUTION_MEMORY_TYPES
from openviking.session.memory.dataclass import ResolvedOperations, StoredLink
from openviking.session.memory.memory_isolation_handler import MemoryIsolationHandler
from openviking.session.memory.memory_updater import (
@@ -265,7 +266,10 @@ class SessionCompressorV2:
registry = create_default_registry()
if allow_self_memory:
- await registry.initialize_memory_files(ctx)
+ await registry.initialize_memory_files(
+ ctx,
+ allowed_memory_types=allowed_memory_types,
+ )
# Initialize telemetry counters before extraction.
telemetry = get_current_telemetry()
@@ -459,7 +463,7 @@ class SessionCompressorV2:
logger.warning(f"Failed to release transaction lock: {e}")
@tracer(ignore_result=True)
- async def extract_agent_memories(
+ async def extract_execution_memories(
self,
messages: List[Message],
ctx: Optional[RequestContext] = None,
@@ -469,22 +473,21 @@ class SessionCompressorV2:
allowed_memory_types: Optional[set[str]] = None,
include_session_skills: Optional[bool] = None,
) -> Dict[str, List[Any]]:
- """Two-phase agent-scope extraction for trajectories, experiences, and session skills."""
+ """Extract trajectory, experience, and session-skill memories from execution context."""
config = get_openviking_config()
- allowed_agent_types = (
- {"trajectories", "experiences"}
+ allowed_execution_types = (
+ set(EXECUTION_MEMORY_TYPES)
if allowed_memory_types is None
- else set(allowed_memory_types)
+ else set(allowed_memory_types) & EXECUTION_MEMORY_TYPES
)
- agent_memory_enabled = config.memory.agent_memory_enabled
- include_trajectories = agent_memory_enabled and "trajectories" in allowed_agent_types
- include_experiences = agent_memory_enabled and "experiences" in allowed_agent_types
+ include_trajectories = "trajectories" in allowed_execution_types
+ include_experiences = "experiences" in allowed_execution_types
if include_session_skills is None:
include_session_skills = bool(
getattr(config.memory, "session_skill_extraction_enabled", False)
)
empty_result: Dict[str, List[Any]] = {"contexts": [], "session_skills": []}
- if not (include_trajectories or include_session_skills):
+ if not include_trajectories:
return empty_result
if not messages or not ctx:
return empty_result
@@ -512,7 +515,7 @@ class SessionCompressorV2:
ctx=ctx,
strict_extract_errors=strict_extract_errors,
phase_label="trajectory",
- allowed_memory_types=allowed_agent_types,
+ allowed_memory_types=allowed_execution_types,
)
if traj_result is None:
return empty_result
@@ -587,7 +590,7 @@ class SessionCompressorV2:
strict_extract_errors=strict_extract_errors,
phase_label=f"experience({traj_uri})",
post_apply=_append_sources_before_unlock,
- allowed_memory_types=allowed_agent_types,
+ allowed_memory_types=allowed_execution_types,
)
if exp_result is None:
fallback_uris = await self._single_existing_experience_uris(
diff --git a/openviking/session/memory/constants.py b/openviking/session/memory/constants.py
new file mode 100644
index 000000000..b8959de95
--- /dev/null
+++ b/openviking/session/memory/constants.py
@@ -0,0 +1,6 @@
+# Copyright (c) 2026 Beijing Volcano Engine Technology Co., Ltd.
+# SPDX-License-Identifier: AGPL-3.0
+
+TRAJECTORY_MEMORY_TYPE = "trajectories"
+EXPERIENCE_MEMORY_TYPE = "experiences"
+EXECUTION_MEMORY_TYPES = frozenset({TRAJECTORY_MEMORY_TYPE, EXPERIENCE_MEMORY_TYPE})
diff --git a/openviking/session/memory/dataclass.py b/openviking/session/memory/dataclass.py
index 2e7f1d2c9..e28553c09 100644
--- a/openviking/session/memory/dataclass.py
+++ b/openviking/session/memory/dataclass.py
@@ -167,7 +167,8 @@ class MemoryTypeSchema(BaseModel):
"upsert", description="Operation mode: 'upsert' (default), 'add_only', or 'update_only'"
)
agent_only: bool = Field(
- False, description="If true, only used by agent memory extraction, not user memory"
+ False,
+ description="If true, only used by execution-derived extraction, not long-term memory",
)
overview_template: Optional[str] = Field(
None, description="Overview template for auto-generating .overview.md files"
diff --git a/openviking/session/memory/memory_isolation_handler.py b/openviking/session/memory/memory_isolation_handler.py
index 4384372d8..b8fbf5284 100644
--- a/openviking/session/memory/memory_isolation_handler.py
+++ b/openviking/session/memory/memory_isolation_handler.py
@@ -14,6 +14,8 @@ from openviking_cli.utils import get_logger
logger = get_logger(__name__)
+_INTERNAL_MEMORY_TYPES = {"session_skills"}
+
@dataclass
class RoleScope:
@@ -106,6 +108,8 @@ class MemoryIsolationHandler:
def allows_schema(self, memory_type_schema: MemoryTypeSchema) -> bool:
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
return True
diff --git a/openviking/session/memory/memory_type_registry.py b/openviking/session/memory/memory_type_registry.py
index 970570bf7..a07c20d17 100644
--- a/openviking/session/memory/memory_type_registry.py
+++ b/openviking/session/memory/memory_type_registry.py
@@ -231,7 +231,11 @@ class MemoryTypeRegistry:
overview_template=data.get("overview_template"),
)
- async def initialize_memory_files(self, ctx: Any) -> None:
+ async def initialize_memory_files(
+ self,
+ ctx: Any,
+ allowed_memory_types: Optional[set[str]] = None,
+ ) -> None:
"""
Initialize memory files with init_value for fields that have it.
@@ -240,6 +244,8 @@ class MemoryTypeRegistry:
Args:
ctx: Request context.
+ allowed_memory_types: Optional memory type whitelist. When set, only
+ initializes templates whose memory_type is included.
"""
from openviking.storage.viking_fs import get_viking_fs
@@ -254,6 +260,9 @@ class MemoryTypeRegistry:
viking_fs = get_viking_fs()
for schema in self.list_all(include_disabled=False):
+ if allowed_memory_types is not None and schema.memory_type not in allowed_memory_types:
+ continue
+
# Must be enabled, have filename_template and content_template
if not schema.enabled or not schema.filename_template or not schema.content_template:
continue
diff --git a/openviking/session/memory/session_extract_context_provider.py b/openviking/session/memory/session_extract_context_provider.py
index 643cca82d..cce533c2e 100644
--- a/openviking/session/memory/session_extract_context_provider.py
+++ b/openviking/session/memory/session_extract_context_provider.py
@@ -409,7 +409,7 @@ After exploring, analyze the conversation and output ALL memory write/edit/delet
pre_fetch_messages = []
pre_fetch_messages.append(self._build_conversation_message())
- # 触发 registry 加载,过滤掉 agent_only 的 schema(trajectory/experience 只由 agent memory 处理)
+ # 触发 registry 加载,过滤掉 agent_only 的 schema(trajectory/experience 由执行提取处理)
schemas = [
s
for s in self._get_registry().list_all(include_disabled=False)
diff --git a/openviking/session/memory_policy.py b/openviking/session/memory_policy.py
index 8e73dcaa0..3c30c360f 100644
--- a/openviking/session/memory_policy.py
+++ b/openviking/session/memory_policy.py
@@ -5,27 +5,12 @@
from __future__ import annotations
from dataclasses import dataclass
-from typing import Any
+from typing import Any, Optional
from openviking_cli.exceptions import InvalidArgumentError
-DEFAULT_LONG_TERM_MEMORY_TYPES = {
- "profile",
- "preferences",
- "entities",
- "events",
- "cases",
- "patterns",
- "tools",
- "skills",
- "identity",
- "soul",
-}
-
-DEFAULT_AGENT_MEMORY_TYPES = {
- "trajectories",
- "experiences",
-}
+_POLICY_KEYS = {"self", "peer", "memory_types"}
+_TARGET_KEYS = {"enabled"}
def _target_enabled(data: Any, *, default_enabled: bool) -> bool:
@@ -33,15 +18,32 @@ def _target_enabled(data: Any, *, default_enabled: bool) -> bool:
return default_enabled
if not isinstance(data, dict):
raise InvalidArgumentError("memory_policy target must be an object")
+ extra_keys = set(data) - _TARGET_KEYS
+ if extra_keys:
+ raise InvalidArgumentError("memory_policy target supports only: enabled")
return bool(data.get("enabled", default_enabled))
+def _parse_memory_types(data: Any) -> Optional[set[str]]:
+ if data is None:
+ return None
+ if not isinstance(data, 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("memory_policy.memory_types must contain non-empty strings")
+ memory_types.add(item)
+ return memory_types
+
+
@dataclass
class MemoryPolicy:
"""Effective memory policy for one commit."""
self_enabled: bool = True
peer_enabled: bool = False
+ memory_types: Optional[set[str]] = None
@classmethod
def default(cls) -> "MemoryPolicy":
@@ -55,22 +57,31 @@ class MemoryPolicy:
return data
if not isinstance(data, dict):
raise InvalidArgumentError("memory_policy must be an object")
+ extra_keys = set(data) - _POLICY_KEYS
+ if extra_keys:
+ raise InvalidArgumentError(
+ "memory_policy supports only: " + ", ".join(sorted(_POLICY_KEYS))
+ )
return cls(
self_enabled=_target_enabled(data.get("self"), default_enabled=True),
peer_enabled=_target_enabled(data.get("peer"), default_enabled=False),
+ memory_types=_parse_memory_types(data.get("memory_types")),
)
- @classmethod
- def merge(cls, session_policy: Any = None, commit_policy: Any = None) -> "MemoryPolicy":
- """Return the policy used by a commit."""
- if commit_policy is not None:
- return cls.from_dict(commit_policy)
- if session_policy is not None:
- return cls.from_dict(session_policy)
- return cls.default()
+ 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
+ if unknown:
+ raise InvalidArgumentError(
+ "Unknown memory_policy.memory_types: " + ", ".join(sorted(unknown))
+ )
def to_dict(self) -> dict[str, Any]:
- return {
+ data: dict[str, Any] = {
"self": {"enabled": self.self_enabled},
"peer": {"enabled": self.peer_enabled},
}
+ 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 a4c42c3c2..765bc82d9 100644
--- a/openviking/session/session.py
+++ b/openviking/session/session.py
@@ -19,11 +19,8 @@ from openviking.message import Message, Part
from openviking.message.part import ContextPart, TextPart, ToolPart
from openviking.server.config import ToolOutputExternalizationConfig
from openviking.server.identity import RequestContext, Role
-from openviking.session.memory_policy import (
- DEFAULT_AGENT_MEMORY_TYPES,
- DEFAULT_LONG_TERM_MEMORY_TYPES,
- MemoryPolicy,
-)
+from openviking.session.memory.constants import EXECUTION_MEMORY_TYPES
+from openviking.session.memory_policy import MemoryPolicy
from openviking.session.tool_result_store import (
ToolResultStore,
build_tool_result_id,
@@ -60,22 +57,29 @@ def _wm_debug(msg: str) -> None:
logger.debug("wm_v2: %s", msg)
-def _known_memory_types() -> set[str]:
- """Return memory types accepted by commit memory_policy."""
- names = set(DEFAULT_LONG_TERM_MEMORY_TYPES) | set(DEFAULT_AGENT_MEMORY_TYPES)
- try:
- from openviking.session.memory.memory_type_registry import MemoryTypeRegistry
+def _enabled_memory_types() -> set[str]:
+ """Return enabled memory type names registered for extraction."""
+ from openviking.session.memory.memory_type_registry import MemoryTypeRegistry
+
+ return set(MemoryTypeRegistry().list_names(include_disabled=False))
+
+
+def _validate_memory_policy_types(policy: MemoryPolicy) -> None:
+ if policy.memory_types is None:
+ return
+ policy.validate_memory_types(_enabled_memory_types())
- names.update(MemoryTypeRegistry().list_names())
- except Exception:
- logger.debug("Failed to load v2 memory type registry", exc_info=True)
- return names
+
+def _split_policy_memory_types(
+ memory_types: Optional[set[str]],
+) -> tuple[Optional[set[str]], Optional[set[str]]]:
+ if memory_types is None:
+ return None, None
+ return memory_types - EXECUTION_MEMORY_TYPES, memory_types & EXECUTION_MEMORY_TYPES
def _default_memory_counts() -> Dict[str, int]:
- counts = dict.fromkeys(sorted(DEFAULT_LONG_TERM_MEMORY_TYPES), 0)
- counts["total"] = 0
- return counts
+ return {"total": 0}
def _message_peer_ids(messages: List[Message]) -> set[str]:
@@ -1034,24 +1038,14 @@ class Session:
return {"tool_results": []}
return await store.list(tool_name=tool_name, limit=limit)
- def commit(
- self,
- keep_recent_count: int = 0,
- memory_policy: Optional[Dict[str, Any]] = None,
- ) -> Dict[str, Any]:
+ def commit(self, keep_recent_count: int = 0) -> Dict[str, Any]:
"""Sync wrapper for commit_async()."""
- return run_async(
- self.commit_async(
- keep_recent_count=keep_recent_count,
- memory_policy=memory_policy,
- )
- )
+ return run_async(self.commit_async(keep_recent_count=keep_recent_count))
@tracer("session.commit.phase1")
async def commit_async(
self,
keep_recent_count: int = 0,
- memory_policy: Optional[Dict[str, Any]] = None,
) -> Dict[str, Any]:
"""Async commit session: archive immediately, extract memories in background.
@@ -1068,8 +1062,6 @@ class Session:
behavior of archiving everything. The plugin's afterTurn path
typically passes its configured value (default 10); the compact
path passes ``0``.
- memory_policy: Optional per-commit extraction policy. When omitted,
- the session default policy is used.
Returns a task_id for tracking Phase 2 progress.
"""
@@ -1079,10 +1071,8 @@ class Session:
trace_id = tracer.get_trace_id()
keep_recent_count = max(0, int(keep_recent_count or 0))
- effective_policy = MemoryPolicy.merge(
- session_policy=self._meta.memory_policy,
- commit_policy=memory_policy,
- )
+ effective_policy = MemoryPolicy.from_dict(self._meta.memory_policy)
+ _validate_memory_policy_types(effective_policy)
effective_memory_policy = effective_policy.to_dict()
logger.info(
f"[TRACER] session_commit started, trace_id={trace_id}, "
@@ -1347,10 +1337,9 @@ class Session:
ctx=self.ctx,
)
- # Summary generation, user memory and agent memory all run concurrently.
+ # Summary, long-term memory, and execution-derived memory run concurrently.
ov_config = get_openviking_config()
memory_extraction_enabled = ov_config.memory.extraction_enabled
- agent_memory_enabled = ov_config.memory.agent_memory_enabled
config_session_skill_extraction_enabled = (
ov_config.memory.session_skill_extraction_enabled
)
@@ -1363,37 +1352,39 @@ class Session:
session_skill_extraction_enabled = (
config_session_skill_extraction_enabled and self_memory_enabled
)
- registered_memory_types = _known_memory_types()
- agent_allowed_types = (
- registered_memory_types & DEFAULT_AGENT_MEMORY_TYPES
- if agent_memory_enabled and memory_extraction_enabled
- else set()
+ memory_type_filter = effective_policy.memory_types
+ long_term_memory_types, execution_memory_types = _split_policy_memory_types(
+ memory_type_filter
)
- self_agent_types = agent_allowed_types if self_memory_enabled else set()
- long_term_allowed_types = (
- registered_memory_types & DEFAULT_LONG_TERM_MEMORY_TYPES
- if memory_extraction_enabled and (self_memory_enabled or allowed_peer_ids)
- else set()
+
+ long_term_has_work = (
+ memory_extraction_enabled
+ and (self_memory_enabled or allowed_peer_ids)
+ and (long_term_memory_types is None or bool(long_term_memory_types))
+ )
+ execution_memory_has_work = (
+ self_memory_enabled
+ and memory_extraction_enabled
+ and (execution_memory_types is None or bool(execution_memory_types))
)
- has_policy_work = bool(
- long_term_allowed_types
- or self_agent_types
- or session_skill_extraction_enabled
+ session_skill_extraction_enabled = (
+ session_skill_extraction_enabled and execution_memory_has_work
)
+ has_policy_work = bool(long_term_has_work or execution_memory_has_work)
if self._session_compressor and has_policy_work:
logger.info(
"Starting post-commit extraction from %s archived messages",
len(messages),
)
- has_agent_memory = hasattr(
- self._session_compressor, "extract_agent_memories"
+ has_execution_memory = hasattr(
+ self._session_compressor, "extract_execution_memories"
)
extraction_tasks: List[Any] = [_run_archive_summary()]
extraction_labels = ["archive_summary"]
- if long_term_allowed_types:
+ if long_term_has_work:
extraction_tasks.append(
self._session_compressor.extract_long_term_memories(
messages=extraction_messages,
@@ -1402,31 +1393,29 @@ class Session:
ctx=self.ctx,
latest_archive_overview=latest_archive_overview,
archive_uri=archive_uri,
- allowed_memory_types=long_term_allowed_types,
+ allowed_memory_types=long_term_memory_types,
allow_self_memory=self_memory_enabled,
allowed_peer_ids=allowed_peer_ids,
)
)
extraction_labels.append("long_term")
- if has_agent_memory and (
- self_agent_types or session_skill_extraction_enabled
- ):
+ if has_execution_memory and execution_memory_has_work:
try:
extraction_tasks.append(
- self._session_compressor.extract_agent_memories(
+ self._session_compressor.extract_execution_memories(
messages=extraction_messages,
ctx=self.ctx,
latest_archive_overview=latest_archive_overview,
archive_uri=archive_uri,
- allowed_memory_types=self_agent_types,
+ allowed_memory_types=execution_memory_types,
include_session_skills=session_skill_extraction_enabled,
)
)
- extraction_labels.append("agent")
+ extraction_labels.append("execution")
except Exception as exc:
logger.error(
- "Agent memory extraction failed: %s",
+ "Execution memory extraction failed: %s",
exc,
exc_info=exc,
)
diff --git a/openviking/sync_client.py b/openviking/sync_client.py
index bd048bea2..6ecc91726 100644
--- a/openviking/sync_client.py
+++ b/openviking/sync_client.py
@@ -136,7 +136,6 @@ class SyncOpenViking:
telemetry: TelemetryRequest = False,
*,
keep_recent_count: int = 0,
- memory_policy: Optional[Dict[str, Any]] = None,
) -> Dict[str, Any]:
"""Commit a session (archive and extract memories)."""
return run_async(
@@ -144,7 +143,6 @@ class SyncOpenViking:
session_id,
telemetry=telemetry,
keep_recent_count=keep_recent_count,
- memory_policy=memory_policy,
)
)
diff --git a/openviking_cli/client/base.py b/openviking_cli/client/base.py
index 9dc394412..066f12b6d 100644
--- a/openviking_cli/client/base.py
+++ b/openviking_cli/client/base.py
@@ -275,7 +275,6 @@ class BaseClient(ABC):
telemetry: TelemetryRequest = False,
*,
keep_recent_count: int = 0,
- memory_policy: Optional[Dict[str, Any]] = None,
) -> Dict[str, Any]:
"""Commit a session (archive and extract memories).
@@ -283,7 +282,6 @@ class BaseClient(ABC):
session_id: Session ID
telemetry: Whether to attach operation telemetry data to the result.
keep_recent_count: Number of recent live messages to retain after commit.
- memory_policy: Optional per-commit extraction policy.
"""
...
diff --git a/openviking_cli/client/http.py b/openviking_cli/client/http.py
index 3c4a60b71..cb84fd31e 100644
--- a/openviking_cli/client/http.py
+++ b/openviking_cli/client/http.py
@@ -894,7 +894,6 @@ class AsyncHTTPClient(BaseClient):
telemetry: TelemetryRequest = False,
*,
keep_recent_count: int = 0,
- memory_policy: Optional[Dict[str, Any]] = None,
) -> Dict[str, Any]:
"""Commit a session (archive and extract memories)."""
telemetry = self._validate_telemetry(telemetry)
@@ -902,8 +901,6 @@ class AsyncHTTPClient(BaseClient):
"keep_recent_count": keep_recent_count,
"telemetry": telemetry,
}
- if memory_policy is not None:
- payload["memory_policy"] = memory_policy
response = await self._http.post(
f"/api/v1/sessions/{session_id}/commit",
json=payload,
diff --git a/openviking_cli/client/sync_http.py b/openviking_cli/client/sync_http.py
index 6dad05bb8..a624896f8 100644
--- a/openviking_cli/client/sync_http.py
+++ b/openviking_cli/client/sync_http.py
@@ -206,7 +206,6 @@ class SyncHTTPClient:
telemetry: TelemetryRequest = False,
*,
keep_recent_count: int = 0,
- memory_policy: Optional[Dict[str, Any]] = None,
) -> Dict[str, Any]:
"""Commit a session (archive and extract memories)."""
return run_async(
@@ -214,7 +213,6 @@ class SyncHTTPClient:
session_id,
telemetry=telemetry,
keep_recent_count=keep_recent_count,
- memory_policy=memory_policy,
)
)
diff --git a/openviking_cli/utils/config/memory_config.py b/openviking_cli/utils/config/memory_config.py
index 317bd1c3f..7f33785ba 100644
--- a/openviking_cli/utils/config/memory_config.py
+++ b/openviking_cli/utils/config/memory_config.py
@@ -2,7 +2,11 @@
# SPDX-License-Identifier: AGPL-3.0
from typing import Any, Dict
-from pydantic import BaseModel, Field, field_validator
+from pydantic import BaseModel, Field, field_validator, model_validator
+
+from openviking_cli.utils.logger import get_logger
+
+logger = get_logger(__name__)
class MemoryConfig(BaseModel):
@@ -32,15 +36,6 @@ class MemoryConfig(BaseModel):
"0 means unlimited retries."
),
)
- agent_memory_enabled: bool = Field(
- default=True,
- description=(
- "Enable trajectory/experience memory extraction. When true (default), "
- "a two-phase pipeline runs after user-memory extraction: Phase 1 extracts "
- "execution trajectories from the conversation; Phase 2 consolidates them "
- "into higher-level experience memories."
- ),
- )
experimental_memory_switch: bool = Field(
default=False,
description=(
@@ -93,6 +88,18 @@ class MemoryConfig(BaseModel):
model_config = {"extra": "forbid"}
+ @model_validator(mode="before")
+ @classmethod
+ def drop_deprecated_agent_memory_enabled(cls, data: Any) -> Any:
+ if isinstance(data, dict) and "agent_memory_enabled" in data:
+ data = dict(data)
+ data.pop("agent_memory_enabled", None)
+ logger.warning(
+ "memory.agent_memory_enabled is deprecated and ignored; "
+ "use session memory_policy.memory_types to control trajectory/experience extraction"
+ )
+ return data
+
@field_validator("version")
@classmethod
def validate_version(cls, value: str) -> str:
diff --git a/test_scripts/memory_policy_compare.py b/test_scripts/memory_policy_compare.py
new file mode 100755
index 000000000..b05271bfb
--- /dev/null
+++ b/test_scripts/memory_policy_compare.py
@@ -0,0 +1,593 @@
+#!/usr/bin/env python3
+"""
+Compare unset and explicit session memory_policy.memory_types behavior with peer enabled.
+
+Run against an existing local server:
+ .venv/bin/python test_scripts/memory_policy_compare.py
+
+Start a local server from ov.conf when needed:
+ .venv/bin/python test_scripts/memory_policy_compare.py --start-server
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import subprocess
+import sys
+import tempfile
+import time
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Iterable, Optional
+from uuid import uuid4
+
+import httpx
+
+import openviking as ov
+
+DEFAULT_CONFIG_PATH = "ov.conf"
+DEFAULT_URL = "http://127.0.0.1:1934"
+DEFAULT_ROOT_KEY = "test"
+DEFAULT_ACCOUNT_PREFIX = "memory-policy-smoke"
+DEFAULT_POLICY_USER = "policy_default"
+FILTERED_POLICY_USER = "policy_filtered"
+PEER_ID = "policy_peer"
+DEFAULT_POLICY = {"peer": {"enabled": True}}
+FILTERED_POLICY = {
+ "peer": {"enabled": True},
+ "memory_types": ["profile", "preferences", "trajectories"],
+}
+FILTERED_ALLOWED_TYPES = {"profile", "preferences", "trajectories"}
+TERMINAL_TASK_STATUSES = {"completed", "failed"}
+
+
+@dataclass(frozen=True)
+class CaseSpec:
+ name: str
+ user_id: str
+ session_id: str
+ api_key: str
+ memory_policy: Optional[dict[str, Any]]
+ allowed_types: Optional[set[str]]
+ required_any_types: set[str]
+
+
+@dataclass(frozen=True)
+class CaseResult:
+ case: CaseSpec
+ task: dict[str, Any]
+ memory_entries: list[dict[str, Any]]
+ memory_types: set[str]
+ archive_diff: Optional[dict[str, Any]]
+ archive_diff_types: set[str]
+ errors: list[str]
+
+ @property
+ def ok(self) -> bool:
+ return not self.errors
+
+
+def load_json_file(path: Path) -> dict[str, Any]:
+ try:
+ return json.loads(path.read_text(encoding="utf-8-sig"))
+ except FileNotFoundError:
+ return {}
+
+
+def default_url_from_config(config: dict[str, Any]) -> str:
+ server = config.get("server") or {}
+ host = server.get("host") or "127.0.0.1"
+ port = server.get("port") or 1934
+ return f"http://{host}:{port}"
+
+
+def root_key_from_config(config: dict[str, Any]) -> str:
+ server = config.get("server") or {}
+ return server.get("root_api_key") or DEFAULT_ROOT_KEY
+
+
+def print_json(title: str, payload: Any) -> None:
+ print(f"\n== {title} ==")
+ print(json.dumps(payload, ensure_ascii=False, indent=2, sort_keys=True))
+
+
+def ensure_server_ready(base_url: str) -> bool:
+ try:
+ response = httpx.get(f"{base_url.rstrip('/')}/health", timeout=5.0)
+ response.raise_for_status()
+ data = response.json()
+ except Exception:
+ return False
+ return data.get("status") == "ok"
+
+
+def wait_server_ready(base_url: str, timeout: float) -> None:
+ deadline = time.time() + timeout
+ while time.time() < deadline:
+ if ensure_server_ready(base_url):
+ return
+ time.sleep(1.0)
+ raise TimeoutError(f"OpenViking server is not ready: {base_url}")
+
+
+def start_server(config_path: Path, base_url: str, startup_timeout: float) -> subprocess.Popen:
+ server_bin = Path(".venv/bin/openviking-server")
+ command = [str(server_bin if server_bin.exists() else "openviking-server")]
+ command.extend(["--config", str(config_path)])
+
+ log_path = Path(tempfile.gettempdir()) / f"openviking-memory-policy-{uuid4().hex}.log"
+ log_file = log_path.open("w", encoding="utf-8")
+ process = subprocess.Popen(
+ command,
+ stdout=log_file,
+ stderr=subprocess.STDOUT,
+ text=True,
+ )
+
+ try:
+ wait_server_ready(base_url, startup_timeout)
+ except Exception:
+ process.terminate()
+ raise RuntimeError(f"Failed to start server. Log: {log_path}") from None
+
+ print(f"Started OpenViking server pid={process.pid}, log={log_path}")
+ return process
+
+
+def close_client(client: Any) -> None:
+ try:
+ client.close()
+ except Exception:
+ pass
+
+
+def make_client(base_url: str, api_key: str, timeout: float):
+ client = ov.SyncHTTPClient(
+ url=base_url,
+ api_key=api_key,
+ timeout=timeout,
+ profile_enabled=False,
+ )
+ client.initialize()
+ return client
+
+
+def bootstrap_users(
+ base_url: str,
+ root_key: str,
+ account_id: str,
+ timeout: float,
+) -> dict[str, str]:
+ admin_client = make_client(base_url, root_key, timeout)
+ try:
+ account = admin_client.admin_create_account(account_id, DEFAULT_POLICY_USER)
+ filtered_user = admin_client.admin_register_user(
+ account_id,
+ FILTERED_POLICY_USER,
+ role="user",
+ )
+ finally:
+ close_client(admin_client)
+
+ user_keys = {
+ DEFAULT_POLICY_USER: account["user_key"],
+ FILTERED_POLICY_USER: filtered_user["user_key"],
+ }
+ print_json(
+ "users",
+ {
+ "account_id": account_id,
+ "users": sorted(user_keys),
+ },
+ )
+ return user_keys
+
+
+def build_messages() -> list[dict[str, Any]]:
+ return [
+ {
+ "role": "user",
+ "content": (
+ "我是林澈,平台工程师,长期维护 OpenViking。"
+ "我的稳定偏好是中文沟通、结论先行、代码改动要小而结构清楚,"
+ "不要新增没有业务含义的 wrapper。2026-06-09 上午,我们决定把 "
+ "PR #2236 的 session memory policy 调整成顶层 memory_types:"
+ "默认不限制类型,显式策略只允许白名单里的多个类型。"
+ ),
+ "created_at": "2026-06-09T10:00:00+08:00",
+ },
+ {
+ "role": "user",
+ "peer_id": PEER_ID,
+ "content": (
+ "我是许知行,PR #2236 的 reviewer,长期负责 session memory policy "
+ "和 peer memory 路由审查。我的稳定偏好是测试必须覆盖 self 和 peer,"
+ "对比默认 memory_types 不设与显式多个白名单类型。2026-06-09 上午,"
+ "我要求 smoke 脚本确认 peer 目录也不会生成白名单之外的 identity 或 soul。"
+ ),
+ "created_at": "2026-06-09T10:00:30+08:00",
+ },
+ {
+ "role": "assistant",
+ "parts": [
+ {
+ "type": "text",
+ "text": (
+ "我会先读取 memory_policy 和 session commit 路径,确认策略解析、"
+ "类型校验和提取 pipeline 的分发点。"
+ ),
+ },
+ {
+ "type": "tool",
+ "tool_id": "inspect_memory_policy",
+ "tool_name": "rg",
+ "skill_uri": "viking://user/skills/codebase_inspection",
+ "tool_input": {
+ "pattern": "memory_types|extract_execution_memories",
+ "path": "openviking/session",
+ },
+ "tool_output": (
+ "Found MemoryPolicy.memory_types as a top-level field. "
+ "Session commit validates it against MemoryTypeRegistry, then passes "
+ "the same whitelist into each memory extraction entry point. "
+ "The default policy enables peer memory and leaves allowed_memory_types "
+ "unset, while an explicit policy passes a whitelist into each extraction "
+ "pipeline."
+ ),
+ "tool_status": "completed",
+ "duration_ms": 22,
+ "prompt_tokens": 128,
+ "completion_tokens": 92,
+ },
+ ],
+ "created_at": "2026-06-09T10:01:00+08:00",
+ },
+ {
+ "role": "assistant",
+ "peer_id": PEER_ID,
+ "content": (
+ "我会在同一份对话里保留你的 peer_id,并在提交后同时扫描 self memory "
+ "和 peer memory,确认过滤策略对两个目标都生效。"
+ ),
+ "created_at": "2026-06-09T10:01:30+08:00",
+ },
+ {
+ "role": "user",
+ "content": (
+ "请写一个 test_scripts 里的脚本,创建两个 user,给他们同一段对话,"
+ "但设置不同 memory_policy。一个只开启 peer 但不设置 memory_types,"
+ "另一个开启 peer 并设置 profile、preferences、trajectories 这几个类型,"
+ "最后对比默认全量和显式白名单在 self 与 peer 两边的产物差异。"
+ ),
+ "created_at": "2026-06-09T10:02:00+08:00",
+ },
+ {
+ "role": "assistant",
+ "parts": [
+ {
+ "type": "text",
+ "text": ("我会用真实 HTTP 服务执行 smoke test,并轮询 commit task 到完成。"),
+ },
+ {
+ "type": "tool",
+ "tool_id": "write_compare_script",
+ "tool_name": "apply_patch",
+ "skill_uri": "viking://user/skills/code_editing",
+ "tool_input": {
+ "file": "test_scripts/memory_policy_compare.py",
+ "operation": "add",
+ },
+ "tool_output": (
+ "Created a script that bootstraps users, creates sessions with "
+ "peer-enabled policies, adds identical messages, commits, polls tasks, "
+ "and compares self and peer memory files by type."
+ ),
+ "tool_status": "completed",
+ "duration_ms": 31,
+ "prompt_tokens": 180,
+ "completion_tokens": 120,
+ },
+ ],
+ "created_at": "2026-06-09T10:03:00+08:00",
+ },
+ {
+ "role": "assistant",
+ "content": (
+ "脚本已完成:未设置 memory_types 的策略应尽量按当前 registry 全量抽取;"
+ "显式策略只能在 self 和 peer 两边产生 profile、preferences、"
+ "trajectories。"
+ ),
+ "created_at": "2026-06-09T10:04:00+08:00",
+ },
+ ]
+
+
+def wait_task(client: Any, task_id: str, timeout: float) -> dict[str, Any]:
+ deadline = time.time() + timeout
+ latest: dict[str, Any] = {}
+ while time.time() < deadline:
+ task = client.get_task(task_id) or {}
+ latest = task
+ status = task.get("status")
+ if status in TERMINAL_TASK_STATUSES:
+ return task
+ time.sleep(2.0)
+ raise TimeoutError(f"Task timed out: {task_id}, latest={latest}")
+
+
+def entry_uri(entry: dict[str, Any]) -> str:
+ return str(entry.get("uri") or "")
+
+
+def collect_memory_entries(client: Any, user_id: str) -> list[dict[str, Any]]:
+ root_uris = [
+ f"viking://user/{user_id}/memories",
+ f"viking://user/{user_id}/peers/{PEER_ID}/memories",
+ ]
+ memory_entries: list[dict[str, Any]] = []
+ for root_uri in root_uris:
+ try:
+ entries = client.ls(root_uri, recursive=True, show_all_hidden=True) or []
+ except Exception:
+ continue
+ memory_entries.extend(entry for entry in entries if isinstance(entry, dict))
+ return memory_entries
+
+
+def is_peer_memory_uri(uri: str) -> bool:
+ return f"/peers/{PEER_ID}/memories/" in uri
+
+
+def memory_type_from_uri(uri: str) -> str:
+ if "/memories/trajectories/" in uri:
+ return "trajectories"
+ if "/memories/experiences/" in uri:
+ return "experiences"
+ if "/memories/preferences/" in uri:
+ return "preferences"
+ if "/memories/entities/" in uri:
+ return "entities"
+ if uri.endswith("/profile.md"):
+ return "profile"
+ if uri.endswith("/identity.md"):
+ return "identity"
+ if uri.endswith("/soul.md"):
+ return "soul"
+ if uri.endswith(".md"):
+ return Path(uri).stem
+ return ""
+
+
+def collect_memory_types(entries: Iterable[dict[str, Any]]) -> set[str]:
+ memory_types = set()
+ for entry in entries:
+ uri = entry_uri(entry)
+ if not uri.endswith(".md"):
+ continue
+ if Path(uri).name.startswith("."):
+ continue
+ memory_type = memory_type_from_uri(uri)
+ if memory_type:
+ memory_types.add(memory_type)
+ return memory_types
+
+
+def extracted_memory_types(memory_types: set[str]) -> set[str]:
+ return set(memory_types)
+
+
+def read_archive_diff(client: Any, archive_uri: str) -> Optional[dict[str, Any]]:
+ try:
+ content = client.read(f"{archive_uri.rstrip('/')}/memory_diff.json")
+ except Exception:
+ return None
+ try:
+ return json.loads(content)
+ except json.JSONDecodeError:
+ return None
+
+
+def collect_archive_diff_types(diff: Optional[dict[str, Any]]) -> set[str]:
+ if not diff:
+ return set()
+ operations = diff.get("operations") or {}
+ memory_types = set()
+ for key in ("adds", "updates", "deletes"):
+ for item in operations.get(key) or []:
+ memory_type = item.get("memory_type")
+ if memory_type:
+ memory_types.add(str(memory_type))
+ return memory_types
+
+
+def run_case(
+ base_url: str,
+ case: CaseSpec,
+ timeout: float,
+) -> CaseResult:
+ client = make_client(base_url, case.api_key, timeout)
+ errors: list[str] = []
+ try:
+ client.create_session(
+ session_id=case.session_id,
+ memory_policy=case.memory_policy,
+ )
+ client.batch_add_messages(case.session_id, build_messages())
+ commit = client.commit_session(case.session_id)
+ task_id = commit.get("task_id")
+ archive_uri = commit.get("archive_uri") or (
+ f"viking://session/{case.session_id}/history/archive_001"
+ )
+ if not task_id:
+ raise RuntimeError(f"Commit did not return task_id: {commit}")
+
+ task = wait_task(client, task_id, timeout)
+ if task.get("status") != "completed":
+ errors.append(f"commit task failed: {task.get('error') or task}")
+
+ entries = collect_memory_entries(client, case.user_id)
+ memory_types = collect_memory_types(entries)
+ extracted_types = extracted_memory_types(memory_types)
+ archive_diff = read_archive_diff(client, archive_uri)
+ archive_diff_types = collect_archive_diff_types(archive_diff)
+
+ if case.required_any_types and not extracted_types & case.required_any_types:
+ errors.append(
+ "missing any expected extracted memory type from: "
+ f"{sorted(case.required_any_types)}"
+ )
+ if not any(is_peer_memory_uri(entry_uri(entry)) for entry in entries):
+ errors.append(f"peer memory did not produce files for peer_id={PEER_ID}")
+
+ if case.allowed_types is not None:
+ outside_allowed = extracted_types - case.allowed_types
+ if outside_allowed:
+ errors.append(
+ f"extracted memory types outside explicit whitelist: {sorted(outside_allowed)}"
+ )
+
+ return CaseResult(
+ case=case,
+ task=task,
+ memory_entries=entries,
+ memory_types=memory_types,
+ archive_diff=archive_diff,
+ archive_diff_types=archive_diff_types,
+ errors=errors,
+ )
+ finally:
+ close_client(client)
+
+
+def result_summary(result: CaseResult) -> dict[str, Any]:
+ memory_files = sorted(
+ entry_uri(entry)
+ for entry in result.memory_entries
+ if entry_uri(entry).endswith(".md") and not Path(entry_uri(entry)).name.startswith(".")
+ )
+ peer_memory_files = [uri for uri in memory_files if is_peer_memory_uri(uri)]
+ return {
+ "case": result.case.name,
+ "user_id": result.case.user_id,
+ "peer_id": PEER_ID,
+ "session_id": result.case.session_id,
+ "memory_policy": result.case.memory_policy,
+ "task_status": result.task.get("status"),
+ "memory_types": sorted(result.memory_types),
+ "extracted_memory_types": sorted(extracted_memory_types(result.memory_types)),
+ "archive_diff_types": sorted(result.archive_diff_types),
+ "memory_files": memory_files,
+ "peer_memory_files": peer_memory_files,
+ "errors": result.errors,
+ }
+
+
+def build_parser() -> argparse.ArgumentParser:
+ parser = argparse.ArgumentParser(
+ description="Compare session memory_policy.memory_types filtering under two users."
+ )
+ parser.add_argument("--config", default=DEFAULT_CONFIG_PATH, help="Path to ov.conf.")
+ parser.add_argument("--url", default="", help="OpenViking server URL.")
+ parser.add_argument("--root-key", default="", help="Root API key.")
+ parser.add_argument("--account", default="", help="Account ID to create.")
+ parser.add_argument(
+ "--timeout",
+ type=float,
+ default=300.0,
+ help="Seconds to wait for server startup and commit tasks.",
+ )
+ parser.add_argument(
+ "--start-server",
+ action="store_true",
+ help="Start .venv/bin/openviking-server --config ov.conf if health check fails.",
+ )
+ parser.add_argument(
+ "--leave-server-running",
+ action="store_true",
+ help="Do not terminate the server process started by this script.",
+ )
+ return parser
+
+
+def main() -> int:
+ args = build_parser().parse_args()
+ config_path = Path(args.config)
+ config = load_json_file(config_path)
+ base_url = (args.url or default_url_from_config(config) or DEFAULT_URL).rstrip("/")
+ root_key = args.root_key or root_key_from_config(config)
+ run_id = time.strftime("%Y%m%d%H%M%S") + "-" + uuid4().hex[:8]
+ account_id = args.account or f"{DEFAULT_ACCOUNT_PREFIX}-{run_id}"
+
+ server_process: Optional[subprocess.Popen] = None
+ if not ensure_server_ready(base_url):
+ if not args.start_server:
+ print(
+ f"OpenViking server is not ready at {base_url}. "
+ "Start it first or pass --start-server.",
+ file=sys.stderr,
+ )
+ return 2
+ server_process = start_server(config_path, base_url, args.timeout)
+
+ try:
+ user_keys = bootstrap_users(base_url, root_key, account_id, args.timeout)
+ cases = [
+ CaseSpec(
+ name="policy_memory_types_unset",
+ user_id=DEFAULT_POLICY_USER,
+ session_id=f"mp_unset_{run_id}",
+ api_key=user_keys[DEFAULT_POLICY_USER],
+ memory_policy=DEFAULT_POLICY,
+ allowed_types=None,
+ required_any_types=FILTERED_ALLOWED_TYPES | {"events", "tools", "experiences"},
+ ),
+ CaseSpec(
+ name="policy_filtered",
+ user_id=FILTERED_POLICY_USER,
+ session_id=f"mp_filtered_{run_id}",
+ api_key=user_keys[FILTERED_POLICY_USER],
+ memory_policy=FILTERED_POLICY,
+ allowed_types=FILTERED_ALLOWED_TYPES,
+ required_any_types=FILTERED_ALLOWED_TYPES,
+ ),
+ ]
+
+ results = [run_case(base_url, case, args.timeout) for case in cases]
+ default_types = extracted_memory_types(results[0].memory_types)
+ filtered_types = extracted_memory_types(results[1].memory_types)
+ default_only_types = default_types - filtered_types
+ if not default_only_types:
+ results[1].errors.append(
+ "no observable type difference between unset memory_types and filtered policy"
+ )
+
+ print_json(
+ "comparison",
+ {
+ "default_only_types": sorted(default_only_types),
+ "filtered_allowed_types": sorted(FILTERED_ALLOWED_TYPES),
+ "cases": [result_summary(result) for result in results],
+ },
+ )
+
+ if all(result.ok for result in results):
+ print(
+ "\nPASS: unset memory_types and explicit memory_types whitelist produced "
+ "different self/peer memory type sets."
+ )
+ return 0
+
+ print("\nFAIL: memory_policy comparison did not match expectations.", file=sys.stderr)
+ return 1
+ finally:
+ if server_process is not None and not args.leave_server_running:
+ server_process.terminate()
+ try:
+ server_process.wait(timeout=10.0)
+ except subprocess.TimeoutExpired:
+ server_process.kill()
+
+
+if __name__ == "__main__":
+ raise SystemExit(main())
diff --git a/tests/integration/test_agent_memory_e2e.py b/tests/integration/test_agent_memory_e2e.py
index 0e8c592cf..8cb87219d 100644
--- a/tests/integration/test_agent_memory_e2e.py
+++ b/tests/integration/test_agent_memory_e2e.py
@@ -17,8 +17,6 @@ Prerequisites
-------------
- ~/.openviking/ov.conf has:
"memory": { "version": "v2" }
- or to explicitly disable:
- "memory": { "version": "v2", "agent_memory_enabled": false }
Run
---
@@ -29,7 +27,6 @@ from __future__ import annotations
import logging
import os
-import shutil
import time
import uuid
from pathlib import Path
@@ -44,7 +41,6 @@ from openviking.telemetry import tracer
from openviking.telemetry.tracer import init_tracer_from_config
from openviking_cli.session.user_id import UserIdentifier
from openviking_cli.utils import run_async
-from openviking_cli.utils.config import OpenVikingConfigSingleton, get_openviking_config
logger = logging.getLogger(__name__)
@@ -219,15 +215,6 @@ def _collect_source_trajectories(client: LocalClient, exp_entries: List[dict]) -
# ── Fixtures ──────────────────────────────────────────────────────────────────
-def agent_memory_config_check():
- """Skip if agent_memory_enabled is false."""
- OpenVikingConfigSingleton._instance = None
- config = get_openviking_config()
- if not getattr(config.memory, "agent_memory_enabled", True):
- pytest.skip("agent_memory_enabled is false in config — skipping agent memory tests")
-
-
@pytest.fixture()
def local_test_env() -> Iterator[Dict[str, object]]:
local_path = Path.cwd() / ".tmp_agent_memory_e2e" / uuid.uuid4().hex[:8]
@@ -262,7 +249,6 @@ def _build_client(env: Dict[str, object], user_id: str) -> LocalClient:
class TestAgentMemoryE2E:
"""End-to-end tests for the agent memory two-phase extraction pipeline."""
- @pytest.mark.usefixtures("agent_memory_config_check")
def test_trajectory_and_experience_extraction(
self,
local_test_env,
diff --git a/tests/session/test_commit_skill_inference.py b/tests/session/test_commit_skill_inference.py
index d5c8dd77c..b47fa9dee 100644
--- a/tests/session/test_commit_skill_inference.py
+++ b/tests/session/test_commit_skill_inference.py
@@ -62,9 +62,10 @@ def _build_duplicate_session_skill_operations() -> ResolvedOperations:
@pytest.mark.asyncio
-async def test_session_compressor_v2_extract_agent_memories_returns_session_skills(monkeypatch):
+async def test_session_compressor_v2_extract_execution_memories_returns_session_skills(
+ monkeypatch,
+):
config = MagicMock()
- config.memory.agent_memory_enabled = False
config.memory.session_skill_extraction_enabled = True
async def _fake_run_extract_phase(
@@ -77,9 +78,10 @@ async def test_session_compressor_v2_extract_agent_memories_returns_session_skil
post_apply=None,
**kwargs,
):
- del self, messages, ctx, strict_extract_errors, post_apply, kwargs
+ del self, messages, ctx, strict_extract_errors, post_apply
assert phase_label == "trajectory"
- assert provider._include_trajectories is False
+ assert kwargs["allowed_memory_types"] == {"trajectories"}
+ assert provider._include_trajectories is True
assert provider._include_session_skills is True
return (
[],
@@ -101,11 +103,13 @@ async def test_session_compressor_v2_extract_agent_memories_returns_session_skil
monkeypatch.setattr(SessionCompressorV2, "_run_extract_phase", _fake_run_extract_phase)
compressor = SessionCompressorV2(vikingdb=MagicMock(), skill_processor=MagicMock())
- result = await compressor.extract_agent_memories(
+ result = await compressor.extract_execution_memories(
messages=[Message(id="m1", role="assistant", parts=[TextPart("Summarize a review flow")])],
ctx=RequestContext(user=UserIdentifier.the_default_user(), role=Role.ROOT),
latest_archive_overview="",
archive_uri="viking://sessions/s1/history/archive_001",
+ allowed_memory_types={"trajectories"},
+ include_session_skills=True,
)
assert result == {
diff --git a/tests/session/test_memory_policy.py b/tests/session/test_memory_policy.py
deleted file mode 100644
index 0a6271d89..000000000
--- a/tests/session/test_memory_policy.py
+++ /dev/null
@@ -1,37 +0,0 @@
-# Copyright (c) 2026 Beijing Volcano Engine Technology Co., Ltd.
-# SPDX-License-Identifier: AGPL-3.0
-
-from openviking.session.memory_policy import MemoryPolicy
-
-
-def test_memory_policy_defaults_to_self_only():
- policy = MemoryPolicy.from_dict(None)
-
- assert policy.self_enabled is True
- assert policy.peer_enabled is False
-
-
-def test_memory_policy_uses_enabled_switches_only():
- policy = MemoryPolicy.from_dict(
- {
- "self": {"enabled": False, "types": ["profile"]},
- "peer": {"enabled": True, "types": ["events"]},
- }
- )
-
- assert policy.self_enabled is False
- assert policy.peer_enabled is True
- assert policy.to_dict() == {
- "self": {"enabled": False},
- "peer": {"enabled": True},
- }
-
-
-def test_memory_policy_commit_replaces_session_policy():
- session_policy = {"peer": {"enabled": True, "types": ["profile"]}}
- commit_policy = {"self": {"enabled": False}, "peer": {"enabled": False}}
-
- policy = MemoryPolicy.merge(session_policy=session_policy, commit_policy=commit_policy)
-
- assert policy.self_enabled is False
- assert policy.peer_enabled is False
diff --git a/tests/session/test_session_commit.py b/tests/session/test_session_commit.py
index b6d664eca..2a9748c8e 100644
--- a/tests/session/test_session_commit.py
+++ b/tests/session/test_session_commit.py
@@ -63,22 +63,23 @@ class TestCommit:
self, session_with_messages: Session, monkeypatch
):
config = MagicMock()
- config.memory.extraction_enabled = False
- config.memory.agent_memory_enabled = False
+ config.memory.extraction_enabled = True
config.memory.session_skill_extraction_enabled = True
monkeypatch.setattr("openviking.session.session.get_openviking_config", lambda: config)
session_with_messages._session_compressor.extract_long_term_memories = AsyncMock(
return_value=[]
)
- if hasattr(session_with_messages._session_compressor, "extract_agent_memories"):
- session_with_messages._session_compressor.extract_agent_memories = AsyncMock(
+ if hasattr(session_with_messages._session_compressor, "extract_execution_memories"):
+ session_with_messages._session_compressor.extract_execution_memories = AsyncMock(
return_value={
"contexts": [],
"session_skills": [{"uri": "viking://user/test/skills/code-review"}],
}
)
+ session_with_messages._meta.memory_policy = {"memory_types": ["trajectories"]}
+
result = await session_with_messages.commit_async()
task_result = await _wait_for_task(result["task_id"])
@@ -89,22 +90,56 @@ class TestCommit:
"viking://user/test/skills/code-review"
]
session_with_messages._session_compressor.extract_long_term_memories.assert_not_awaited()
- session_with_messages._session_compressor.extract_agent_memories.assert_awaited_once()
+ session_with_messages._session_compressor.extract_execution_memories.assert_awaited_once()
+ call_kwargs = (
+ session_with_messages._session_compressor.extract_execution_memories.call_args.kwargs
+ )
+ assert call_kwargs["allowed_memory_types"] == {"trajectories"}
+ assert call_kwargs["include_session_skills"] is True
+
+ async def test_commit_skips_session_skills_without_execution_memory_type(
+ self, session_with_messages: Session, monkeypatch
+ ):
+ config = MagicMock()
+ config.memory.extraction_enabled = True
+ config.memory.session_skill_extraction_enabled = True
+ monkeypatch.setattr("openviking.session.session.get_openviking_config", lambda: config)
+
+ session_with_messages._session_compressor.extract_long_term_memories = AsyncMock(
+ return_value=[]
+ )
+ if hasattr(session_with_messages._session_compressor, "extract_execution_memories"):
+ session_with_messages._session_compressor.extract_execution_memories = AsyncMock(
+ return_value={
+ "contexts": [],
+ "session_skills": [{"uri": "viking://user/test/skills/code-review"}],
+ }
+ )
+
+ session_with_messages._meta.memory_policy = {"memory_types": ["profile"]}
+
+ 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"]["memories_extracted"] == {}
+ assert task_result["result"]["session_skills_extracted"] == 0
+ session_with_messages._session_compressor.extract_long_term_memories.assert_awaited_once()
+ session_with_messages._session_compressor.extract_execution_memories.assert_not_awaited()
async def test_commit_skips_session_skill_extraction_when_disabled(
self, session_with_messages: Session, monkeypatch
):
config = MagicMock()
config.memory.extraction_enabled = True
- config.memory.agent_memory_enabled = False
config.memory.session_skill_extraction_enabled = False
monkeypatch.setattr("openviking.session.session.get_openviking_config", lambda: config)
session_with_messages._session_compressor.extract_long_term_memories = AsyncMock(
return_value=[]
)
- if hasattr(session_with_messages._session_compressor, "extract_agent_memories"):
- session_with_messages._session_compressor.extract_agent_memories = AsyncMock(
+ if hasattr(session_with_messages._session_compressor, "extract_execution_memories"):
+ session_with_messages._session_compressor.extract_execution_memories = AsyncMock(
return_value={"contexts": [], "session_skills": []}
)
@@ -115,7 +150,11 @@ class TestCommit:
assert task_result["result"]["session_skills_extracted"] == 0
assert task_result["result"]["session_skill_uris"] == []
session_with_messages._session_compressor.extract_long_term_memories.assert_awaited_once()
- session_with_messages._session_compressor.extract_agent_memories.assert_not_awaited()
+ session_with_messages._session_compressor.extract_execution_memories.assert_awaited_once()
+ call_kwargs = (
+ session_with_messages._session_compressor.extract_execution_memories.call_args.kwargs
+ )
+ assert call_kwargs["include_session_skills"] is False
async def test_commit_routes_peer_memory_with_single_full_context_pass(
self,
@@ -125,13 +164,12 @@ class TestCommit:
"""Peer memory uses one full-context extraction and operation-level routing."""
config = MagicMock()
config.memory.extraction_enabled = True
- config.memory.agent_memory_enabled = True
config.memory.session_skill_extraction_enabled = True
monkeypatch.setattr("openviking.session.session.get_openviking_config", lambda: config)
session = client.session(session_id="peer_memory_role_routing_test")
long_term_calls: list[dict] = []
- agent_calls: list[dict] = []
+ execution_calls: list[dict] = []
async def fake_summary(messages, latest_archive_overview=""):
del messages, latest_archive_overview
@@ -158,7 +196,7 @@ class TestCommit:
)
return []
- async def fake_agent_extract(
+ async def fake_execution_extract(
*,
messages,
allowed_memory_types,
@@ -166,7 +204,7 @@ class TestCommit:
**kwargs,
):
del kwargs
- agent_calls.append(
+ execution_calls.append(
{
"allowed_memory_types": set(allowed_memory_types or set()),
"include_session_skills": include_session_skills,
@@ -178,7 +216,7 @@ class TestCommit:
monkeypatch.setattr(session, "_generate_archive_summary_async", fake_summary)
monkeypatch.setattr(session._session_compressor, "extract_long_term_memories", fake_extract)
monkeypatch.setattr(
- session._session_compressor, "extract_agent_memories", fake_agent_extract
+ session._session_compressor, "extract_execution_memories", fake_execution_extract
)
session.add_message(
@@ -192,12 +230,13 @@ class TestCommit:
peer_id="web:visitor:alice",
)
- result = await session.commit_async(
- memory_policy={
- "self": {"enabled": False},
- "peer": {"enabled": True, "types": ["profile"]},
- }
- )
+ session._meta.memory_policy = {
+ "self": {"enabled": False},
+ "peer": {"enabled": True},
+ "memory_types": ["profile"],
+ }
+
+ result = await session.commit_async()
task_result = await _wait_for_task(result["task_id"])
assert task_result["status"] == "completed"
@@ -205,16 +244,7 @@ class TestCommit:
assert long_term_calls == [
{
"allowed_memory_types": {
- "cases",
- "entities",
- "events",
- "identity",
- "patterns",
- "preferences",
"profile",
- "skills",
- "soul",
- "tools",
},
"allow_self_memory": False,
"allowed_peer_ids": {"web:visitor:alice"},
@@ -222,7 +252,7 @@ class TestCommit:
"peer_ids": ["web:visitor:alice", "web:visitor:alice"],
},
]
- assert agent_calls == []
+ assert execution_calls == []
async def test_commit_archives_messages(self, session_with_messages: Session):
"""Test commit archives messages"""
@@ -304,14 +334,12 @@ class TestCommit:
telemetry=False,
*,
keep_recent_count=0,
- memory_policy=None,
):
calls.append(
{
"session_id": session_id,
"telemetry": telemetry,
"keep_recent_count": keep_recent_count,
- "memory_policy": memory_policy,
}
)
return {"task_id": "task-1"}
@@ -326,7 +354,6 @@ class TestCommit:
"session_id": "s1",
"telemetry": True,
"keep_recent_count": 0,
- "memory_policy": None,
}
]
@@ -340,14 +367,12 @@ class TestCommit:
telemetry=False,
*,
keep_recent_count=0,
- memory_policy=None,
):
calls.append(
{
"session_id": session_id,
"telemetry": telemetry,
"keep_recent_count": keep_recent_count,
- "memory_policy": memory_policy,
}
)
return {"task_id": "task-1"}
@@ -362,7 +387,6 @@ class TestCommit:
"session_id": "s1",
"telemetry": True,
"keep_recent_count": 0,
- "memory_policy": None,
}
]
diff --git a/tests/test_config_loader.py b/tests/test_config_loader.py
index 611d898a4..b1d3e83f5 100644
--- a/tests/test_config_loader.py
+++ b/tests/test_config_loader.py
@@ -199,7 +199,7 @@ def test_openviking_config_rejects_memory_v1(monkeypatch):
OpenVikingConfigSingleton.reset_instance()
-def test_openviking_config_memory_agent_memory_enabled(monkeypatch):
+def test_openviking_config_ignores_deprecated_agent_memory_enabled(monkeypatch):
monkeypatch.setenv(OPENVIKING_CONFIG_ENV, "/tmp/codex-no-config.json")
from openviking_cli.utils.config.open_viking_config import (
@@ -207,16 +207,13 @@ def test_openviking_config_memory_agent_memory_enabled(monkeypatch):
OpenVikingConfigSingleton,
)
- default_config = OpenVikingConfig.from_dict({})
- disabled_config = OpenVikingConfig.from_dict({"memory": {"agent_memory_enabled": False}})
+ legacy_config = OpenVikingConfig.from_dict({"memory": {"agent_memory_enabled": False}})
experimental_config = OpenVikingConfig.from_dict(
{"memory": {"experimental_memory_switch": True}}
)
- assert default_config.memory.agent_memory_enabled is True
- assert disabled_config.memory.agent_memory_enabled is False
+ assert not hasattr(legacy_config.memory, "agent_memory_enabled")
assert experimental_config.memory.experimental_memory_switch is True
- assert experimental_config.memory.agent_memory_enabled is True
OpenVikingConfigSingleton.reset_instance()
diff --git a/tests/unit/session/test_memory_policy.py b/tests/unit/session/test_memory_policy.py
new file mode 100644
index 000000000..f46f1dbd9
--- /dev/null
+++ b/tests/unit/session/test_memory_policy.py
@@ -0,0 +1,86 @@
+# Copyright (c) 2026 Beijing Volcano Engine Technology Co., Ltd.
+# SPDX-License-Identifier: AGPL-3.0
+
+import pytest
+
+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_cli.exceptions import InvalidArgumentError
+
+
+def test_memory_policy_defaults_to_self_only():
+ policy = MemoryPolicy.from_dict(None)
+
+ assert policy.self_enabled is True
+ assert policy.peer_enabled is False
+ assert policy.memory_types is None
+
+
+def test_memory_policy_uses_top_level_memory_types():
+ policy = MemoryPolicy.from_dict(
+ {
+ "self": {"enabled": False},
+ "peer": {"enabled": True},
+ "memory_types": ["profile", "events"],
+ }
+ )
+
+ assert policy.self_enabled is False
+ assert policy.peer_enabled is True
+ assert policy.memory_types == {"profile", "events"}
+ assert policy.to_dict() == {
+ "self": {"enabled": False},
+ "peer": {"enabled": True},
+ "memory_types": ["events", "profile"],
+ }
+
+
+def test_memory_policy_rejects_invalid_memory_types():
+ policy = MemoryPolicy.from_dict({"memory_types": ["profile", "missing"]})
+
+ with pytest.raises(InvalidArgumentError, match="missing"):
+ policy.validate_memory_types({"profile"})
+
+ assert MemoryPolicy.from_dict({"memory_types": ["experiences"]}).memory_types == {"experiences"}
+
+
+async def test_initialize_memory_files_respects_memory_type_filter(monkeypatch):
+ class FakeVikingFS:
+ def __init__(self):
+ self.written_uris = []
+
+ async def read_file(self, uri, ctx=None):
+ raise FileNotFoundError(uri)
+
+ async def write_file(self, uri, content, ctx=None):
+ del content, ctx
+ self.written_uris.append(uri)
+
+ def schema(memory_type: str, filename: str) -> MemoryTypeSchema:
+ return MemoryTypeSchema(
+ memory_type=memory_type,
+ directory="viking://user/{{ user_space }}/memories",
+ filename_template=filename,
+ content_template="{{ content }}",
+ fields=[
+ MemoryField(
+ name="content",
+ field_type=FieldType.STRING,
+ init_value=memory_type,
+ )
+ ],
+ )
+
+ fake_fs = FakeVikingFS()
+ monkeypatch.setattr("openviking.storage.viking_fs.get_viking_fs", lambda: fake_fs)
+
+ registry = MemoryTypeRegistry(load_schemas=False)
+ registry.register(schema("identity", "identity.md"))
+ registry.register(schema("profile", "profile.md"))
+
+ ctx = type("Ctx", (), {"user": type("User", (), {"user_id": "alice"})()})()
+ await registry.initialize_memory_files(ctx, allowed_memory_types={"profile"})
+
+ assert fake_fs.written_uris == ["viking://user/alice/memories/profile.md"]