Self-evolving Context Database for AI Agents. Unify Agent Memory, Knowledge RAG and Skills.
Python agent-contextagent-memoryagent-pluginsagentic-ragcontext-databasedsh-pluginknowledge-basememorymemory-managementself-evolvingvector-database
feat(bot): Bot session compact by using openviking, ov client add function and param (#2284)
DuTaode443fdd4859
diff --git a/bot/docs/vikingbot-openviking-context-plan.md b/bot/docs/vikingbot-openviking-context-plan.mdnew file mode 100644index 000000000..6bdf6491f--- /dev/null+++ b/bot/docs/vikingbot-openviking-context-plan.md@@ -0,0 +1,464 @@+# VikingBot 接入 OpenViking 会话压缩改造方案++## 结论++该方案可行,但不能直接沿用当前 VikingBot 的 OpenViking 接入方式。++当前 OpenViking 服务端已经具备以下关键能力:++- 稳定 session 的消息追加+- `pending_tokens` 累积+- `commit(keep_recent_count=...)`+- `get_session_context()` 返回 `latest_archive_overview` 与 live messages++真正需要改造的是 VikingBot 侧的写路径、读路径、配置与旧压缩链路的退场策略。++## 目标++把 VikingBot 的长对话压缩链路改为:++1. 同一个 bot session 持续写入同一个 OpenViking session。+2. 每轮仅增量同步本轮新增消息,不重复全量重传。+3. 当 OpenViking session 的 `pending_tokens` 达到阈值时触发 `commit`。+4. 下一轮模型调用前,从 OpenViking 读取已压缩上下文。+5. 本地 session 在未压缩前保留原始消息日志;OpenViking commit 成功后清空本地 JSONL,由 OpenViking 负责长上下文压缩与回放。++## 非目标++第一版不做以下事情:++- 不让 OpenViking 完全替代本地 session 存储。+- 不把全部 tool trace / reasoning 直接纳入 OpenViking 压缩主链路。+- 不依赖 memory extraction 完成后才能继续下一轮对话。+- 不同时保留两套自动压缩主链路并行工作。++## 当前实现与方案的关键差异++### 1. 当前 `ov_server.py` 不是稳定 session 模式++当前 `bot/vikingbot/openviking_mount/ov_server.py` 的 `commit(...)` 会在每次提交时重新创建 session,再把整段消息写入并立刻 commit。++这与目标方案冲突,因为它会导致:++- `pending_tokens` 无法持续累积+- 下一轮无法从同一个 session 取回压缩结果+- 无法做真正的增量同步++因此,这个文件必须从“一次性提交器”改造成“稳定 session 访问层”。++### 2. 当前 `loop.py` 仍以本地 history 为主++当前 `bot/vikingbot/agent/loop.py` 仍然使用:++- `session.get_history(...)` 作为模型 history+- `len(session.messages) > self.memory_window` 作为本地自动压缩触发条件++这意味着现有主链路仍是“本地 session 驱动”,而不是“OpenViking session 驱动”。++### 3. 当前 `context.py` 只会拼本地 history++当前 `bot/vikingbot/agent/context.py` 的 prompt 组装仍是:++1. system prompt+2. 本地 history+3. memory/context 注入+4. 当前 user message++如果要接入 OpenViking 压缩上下文,必须显式扩展 prompt assembly。++### 4. 现有旧 compact hook 会与新链路冲突++当前 `bot/vikingbot/hooks/builtins/openviking_hooks.py` 里仍有旧的 `message.compact` 逻辑:++- 有的模式下会把 session 拆成 admin session + per-user session+- 这与新方案的“一个房间对应一个稳定 OV session”冲突++因此新链路启用后,旧 compact hook 必须被禁用、绕过或显式降级为非主路径。++## 设计原则++### 1. OpenViking 负责长上下文压缩,本地 session 负责压缩前原始日志++第一版不建议让 OpenViking 直接替代本地 session 的短期落盘能力。++推荐职责划分:++- 本地 session:在压缩前保存原始消息,兼容现有 provider-specific 字段+- OpenViking session:保存用于长对话压缩和回放的核心消息链路++达到 token/window 阈值并成功 commit 后,本地 session JSONL 会被清空,下一轮通过 OpenViking context 回放已压缩历史。++### 2. OpenViking session 必须稳定++一个 `SessionKey.safe_name()` 对应一个稳定的 `ov_session_id`。++第一版建议直接使用:++- `ov_session_id = SessionKey.safe_name()`++不再在每次 commit 时重新 `create_session()`。++### 3. OpenViking 读路径优先,本地只补 unsynced delta++OpenViking 的 `get_session_context()` 返回的不是纯摘要,而是:++- `latest_archive_overview`+- pending archive messages+- 当前 live messages++因此,VikingBot 读路径不能再把本地 history 整段拼进去。++正确规则应为:++- 以 OpenViking 返回内容作为主 history+- 本地仅补“尚未成功写入 OpenViking 的尾部 delta”++否则会产生重复上下文。++### 4. 请求身份与消息说话人分离++群聊场景中要区分两层身份:++- OpenViking request identity:谁在发起这次 API 调用+- message speaker identity:这条消息是谁说的++第一版建议:++- 请求继续使用当前合法的 bot/account/user 身份+- 每条消息的真实说话人通过 `role_id` 记录++不要把“当前 `sender_id`”直接等同于每次请求的 OpenViking user 身份,否则会和现有权限/命名空间语义冲突。++## 核心方案++## 1. 稳定的 OpenViking Session 绑定++在本地 session metadata 中维护:++```json+{+ "openviking": {+ "enabled": true,+ "session_id": "<SessionKey.safe_name()>",+ "last_synced_local_index": 0,+ "last_commit_at": null,+ "last_pending_tokens": 0,+ "last_context_read_at": null,+ "last_sync_status": "idle"+ }+}+```++字段说明:++- `session_id`: 稳定的 OpenViking session id+- `last_synced_local_index`: 已成功同步到 OpenViking 的本地消息下标上界+- `last_commit_at`: 最近一次 commit 时间+- `last_pending_tokens`: 最近一次观测到的 `pending_tokens`+- `last_context_read_at`: 最近一次读 context 时间+- `last_sync_status`: `idle` / `syncing` / `error`++其中最关键的是 `last_synced_local_index`,它决定增量同步与去重是否正确。++## 2. 写路径:每轮结束后增量同步到 OpenViking++写路径触发点位于 `bot/vikingbot/agent/loop.py` 当前一轮完成、本地 `session.add_message(...)` + `save(...)` 之后。++### 同步内容++第一版只同步核心对话消息:++- user message+- assistant final content++第一版不建议写入:++- 全量 tool trace+- `reasoning_content`+- 大体积工具输出++原因:++- 这些内容会显著放大压缩噪声+- 当前 provider replay 仍主要依赖本地 session+- 第一版目标是先打通稳定会话压缩闭环,而不是完整镜像全部调试信息++### 同步流程++```text+1. 读取 session.metadata.openviking+2. 若不存在 session_id,则创建/确保稳定 session+3. 根据 last_synced_local_index 找出新增消息+4. 将新增消息转换为 OV message parts+5. 调用 append_messages / batch_add_messages 写入 OV+6. 读取 session meta,获取 pending_tokens+7. 若 pending_tokens >= commit_token_threshold 或消息数达到 memory_window,则触发 commit_session(keep_recent_count=N)+8. 更新本地 metadata 中的同步游标与快照+9. 如果本次实际执行了 commit,则清空本地 session JSONL,并重置本地同步游标但保留稳定 session_id+```++### 写路径要求++- 只在“成功写入 OV”后推进 `last_synced_local_index`+- commit 失败不应回滚已成功写入的消息游标+- commit 成功代表本轮压缩完成,应清空本地 session JSONL;后续 prompt 由 OpenViking context + 新的本地未同步 tail 组成+- commit 与 extract 异步执行时,下一轮仍可继续读取 session context++## 3. 读路径:模型调用前优先从 OpenViking 组装 history++读路径触发点位于 `bot/vikingbot/agent/loop.py` 当前构建 `messages = await message_context.build_messages(...)` 之前。++### 读取流程++```text+1. 读取本地 metadata.openviking+2. 若未启用或尚未建立稳定 session,则退化为本地 history 模式+3. 调用 get_session_context(session_id, token_budget)+4. 取回 latest_archive_overview + messages+5. 根据 last_synced_local_index,仅补本地未同步 delta+6. 将组装后的 history 传给 ContextBuilder.build_messages(...)+```++### 推荐上下文顺序++1. system prompt+2. OpenViking `latest_archive_overview`+3. OpenViking `messages`+4. 本地 unsynced delta history+5. 当前 user message++### 去重规则++这是第一版最关键的边界条件:++- 不能再把本地 `session.get_history(...)` 全量拼到 OpenViking context 后面+- 本地只允许补尚未成功同步到 OpenViking 的消息+- 一旦消息已确认 append 成功,就不应再出现在 local delta 中++否则很容易出现重复轮次,导致模型重复理解、工具误触发或 token 浪费。++## 4. token budget 的使用方式++`session_context_token_budget` 不能被视为最终 prompt 的硬上限。++第一版应采用两层预算:++### 第一层:OpenViking context budget++用于控制调用 `get_session_context(session_id, token_budget=...)` 的预算目标。++### 第二层:VikingBot 最终 prompt trim++在组装出:++- OV overview+- OV messages+- local unsynced delta+- current user message++之后,仍需在 VikingBot 侧做一次最终裁剪,确保不会超过 provider 的上下文限制。++否则在大群聊或消息内容较长时,仍可能超出模型窗口。++## 5. 群聊语义++群聊推荐语义如下:++- 一个聊天房间对应一个稳定 `ov_session_id`+- OpenViking request identity 继续按当前 bot/account 配置走+- 每条 user/assistant message 的实际说话者写入 `role_id`++建议映射:++- user message: `role="user"`, `role_id=<真实 sender_id>`+- assistant message: `role="assistant"`, `role_id=<bot/agent id 或默认 assistant 标识>`++这样可以同时满足:++- 会话不被拆碎+- 群聊参与者身份可保留+- 不破坏当前 OpenViking 的身份回退逻辑++## 需要改动的文件++### 1. `bot/vikingbot/openviking_mount/ov_server.py`++把现有一次性 `commit(...)` 改造成稳定 session 访问层。++建议新增或重构为以下接口:++- `ensure_session(session_id: str) -> dict`+- `append_messages(session_id: str, messages: list[dict], role_id_resolver=...) -> dict`+- `get_session(session_id: str) -> dict`+- `get_session_context(session_id: str, token_budget: int) -> dict`+- `commit_session(session_id: str, keep_recent_count: int = 0) -> dict`++要求:++- 不再每次重新创建 session+- 允许批量追加消息+- 能返回最新 `pending_tokens`+- commit 时能传 `keep_recent_count`++### 2. `bot/vikingbot/agent/loop.py`++需要新增两段逻辑:++- 模型调用前:读取 OV context 并构造 history+- 一轮结束后:把本轮新增消息增量同步到 OV,并按阈值决定是否 commit++同时需要关闭或门控当前本地自动 compact 主链路:++- 当 `session_context_enabled=true` 时,不再使用 `len(session.messages) > self.memory_window` 触发旧压缩主链路+- `/compact` 可保留为显式命令,但行为要重新定义,避免与新链路重复++### 3. `bot/vikingbot/agent/context.py`++需要让 `build_messages(...)` 支持接收“外部已组装好的 history”。++推荐方式:++- `loop.py` 先准备好 `history`+- `context.py` 只负责拼:system prompt、memory、当前 user message++这样可以避免把 OpenViking 逻辑硬塞进 `ContextBuilder` 内部。++### 4. `bot/vikingbot/session/manager.py`++当前 metadata merge 已支持嵌套字典,可直接用于持久化:++- `metadata["openviking"][...]`++这里只需要补充新字段的读写约定,不需要重新设计存储格式。++### 5. `bot/vikingbot/config/schema.py`++在 `AgentsConfig` 中增加配置项:++- `session_context_enabled: bool = False`+- `session_context_token_budget: int = 12000`+- `commit_token_threshold: int = 6000`+- `commit_keep_recent_count: int = 10`++其中:++- `session_context_enabled`:总开关+- `session_context_token_budget`:OV context 读取预算+- `commit_token_threshold`:触发 commit 的阈值+- `commit_keep_recent_count`:commit 后保留的 recent live messages 数量++## OpenViking Python Client 需要补的能力++虽然 OpenViking 服务端已支持 `keep_recent_count`,但当前 Python client wrapper 还没有把这个参数完整透出给 VikingBot。++需要修改:++- `openviking/async_client.py`+- `openviking/client/session.py`++建议补齐以下调用能力:++- `commit_session(session_id, keep_recent_count=0, telemetry=False)`+- `Session.commit(keep_recent_count=0, telemetry=False)`+- `Session.commit_async(keep_recent_count=0, telemetry=False)`++否则 VikingBot 在 `AgentsConfig` 配置了 `commit_keep_recent_count` 也无法真正生效。++## 与旧链路的共存策略++### 必须处理的冲突点++以下旧链路会与新方案冲突:++- `bot/vikingbot/hooks/builtins/openviking_hooks.py`+- `bot/vikingbot/agent/loop.py` 中基于 `memory_window` 的自动 compact+- 任何仍按“全量 session -> 一次性 commit”的旧调用点++### 推荐策略++当 `session_context_enabled=true` 时:++1. 禁用旧的 `message.compact` OpenViking hook 主路径+2. 禁用 `len(session.messages) > self.memory_window` 的旧自动压缩+3. 保留 `/compact` 作为显式运维命令,但它应调用新的 stable-session commit 逻辑,而不是旧 fanout 逻辑++## 分阶段实施++## 第一阶段:打通最小闭环++目标:不动 provider 行为的前提下,让 OpenViking 真正接管长对话压缩。++实施项:++1. 重构 `ov_server.py` 为稳定 session 访问层+2. 在 `loop.py` 中接入 after-turn 增量同步+3. 在 `loop.py` 中接入 before-call OV context 读取+4. 在本地 metadata 中保存 `openviking` 同步状态+5. 启用去重规则:本地仅补 unsynced delta++验收标准:++- 同一 session 多轮对话使用同一个 `ov_session_id`+- `pending_tokens` 可持续增长+- 达到阈值后能成功 commit+- 下一轮能读到 `latest_archive_overview` 和 live messages+- prompt 中无重复历史片段++## 第二阶段:补齐 keep_recent_count 与预算控制++实施项:++1. 修改 OpenViking Python client wrapper+2. 让 `commit_keep_recent_count` 配置生效+3. 在 VikingBot 侧增加最终 prompt trim++验收标准:++- commit 后最近 N 条消息仍保留在 live session 中+- 长会话下 prompt 大小可控+- 不因 context 过长导致 provider 调用失败++## 第三阶段:清理旧链路++实施项:++1. 门控旧 `message.compact` hook+2. 门控旧 `memory_window` 自动 compact+3. 明确 `/compact` 与新方案的关系+4. 检查其他工具或工厂函数是否仍依赖旧一次性 commit 逻辑++验收标准:++- 新旧链路不会同时对同一 session 生效+- 群聊不会被拆成多个 OV session+- 回归测试中 history 组装路径唯一且可解释++## 风险与注意事项++### 1. 重复上下文风险++如果本地 delta 计算不准确,最容易出现消息重复拼接。++这是第一版必须优先规避的问题。++### 2. provider-specific 字段丢失风险++当前本地 session 会保留部分 provider 特有字段,例如 `reasoning_content`。++因此第一版推荐保留“本地原始日志 + OV 压缩层”的双层职责,而不是直接完全切换到 OV history。++### 3. 群聊身份映射风险++如果直接把 `sender_id` 当作每次 OV 请求 user 身份,容易与当前 account/user/agent 权限语义冲突。++应优先通过 `role_id` 保留真实说话人。++### 4. 提取异步性的认知风险++commit 之后的 memory extraction 是后台过程。++下一轮对话可依赖 session context,但不要把“新 memory 必然已可检索”当成同步保证。++## 一句话总结++把 VikingBot 改成“本地原始日志 + OpenViking 长上下文压缩层”的双层结构:每轮增量写入稳定 OV session,达到 `pending_tokens` 阈值就 commit,下一轮优先读取 `latest_archive_overview + live messages`,本地只补尚未同步的 delta,并在启用新链路后退场旧的 compact/fanout 逻辑。diff --git a/bot/tests/test_agent_loop_outcome.py b/bot/tests/test_agent_loop_outcome.pyindex 473220206..889140413 100644--- a/bot/tests/test_agent_loop_outcome.py+++ b/bot/tests/test_agent_loop_outcome.py@@ -3,6 +3,7 @@ from datetime import datetimefrom pathlib import Pathimport pytest+from vikingbot.agent import loop as loop_modulefrom vikingbot.agent.loop import AgentLoopfrom vikingbot.bus.events import InboundMessage, OutboundEventTypefrom vikingbot.bus.queue import MessageBus@@ -32,6 +33,45 @@ class _FakeLangfuseClient:self.calls.append((response_id, metadata))return metadata+ def update_response_outcome(self, response_id, outcome_label, outcome_payload):+ self.calls.append((response_id, outcome_label, outcome_payload))+ return outcome_payload+++class _FakeOVClient:+ def __init__(self, *, context_payload=None, pending_tokens=None):+ self.context_payload = context_payload or {}+ self.pending_tokens = list(pending_tokens or [])+ self.context_calls = []+ self.append_calls = []+ self.commit_calls = []+ self.session_calls = []++ async def get_session_context(self, session_id, token_budget):+ self.context_calls.append((session_id, token_budget))+ return self.context_payload++ async def append_messages(+ self,+ session_id,+ messages,+ default_user_role_id=None,+ session_user_id=None,+ ):+ self.append_calls.append(+ (session_id, list(messages), default_user_role_id, session_user_id)+ )+ return {"session_id": session_id, "added": len(messages), "message_count": len(messages)}++ async def get_session(self, session_id, user_id=None):+ self.session_calls.append((session_id, user_id))+ next_pending_tokens = self.pending_tokens.pop(0) if self.pending_tokens else 0+ return {"session_id": session_id, "pending_tokens": next_pending_tokens}++ async def commit_session(self, session_id, keep_recent_count=0, user_id=None):+ self.commit_calls.append((session_id, keep_recent_count, user_id))+ return {"session_id": session_id, "status": "accepted"}+@pytest.mark.asyncioasync def test_agent_loop_evaluates_previous_response_outcome_before_new_user_turn(@@ -85,6 +125,73 @@ async def test_agent_loop_evaluates_previous_response_outcome_before_new_user_tuassert persisted_session.metadata["response_outcomes"]["resp-123"]["outcome_label"] == "reasked"+async def test_agent_loop_evaluates_previous_response_outcome_before_openviking_precommit_clear(+ temp_dir: Path, monkeypatch+):+ monkeypatch.setattr(AgentLoop, "_register_builtin_hooks", lambda self: None)+ monkeypatch.setattr(AgentLoop, "_register_default_tools", lambda self: None)+ monkeypatch.setattr("vikingbot.agent.loop.SubagentManager", _FakeSubagentManager)++ async def fake_run_agent_loop(self, **kwargs):+ return "final answer", None, [], {"prompt_tokens": 1, "completion_tokens": 1}, 1++ fake_langfuse = _FakeLangfuseClient()+ monkeypatch.setattr(AgentLoop, "_run_agent_loop", fake_run_agent_loop)+ monkeypatch.setattr(+ "vikingbot.agent.loop.LangfuseClient.get_instance",+ staticmethod(lambda: fake_langfuse),+ )++ bus = MessageBus()+ config = Config(+ storage_workspace=str(temp_dir),+ agents={+ "session_context_enabled": True,+ "commit_token_threshold": 1,+ "commit_keep_recent_count": 0,+ },+ )+ loop = AgentLoop(+ bus=bus,+ provider=_FakeProvider(),+ workspace=temp_dir / "workspace",+ config=config,+ )++ async def fake_precommit(session, msg):+ session.clear()+ await loop.sessions.save(session)++ monkeypatch.setattr(loop, "_maybe_commit_openviking_before_turn", fake_precommit)++ session_key = SessionKey(type="cli", channel_id="default", chat_id="session-precommit-clear")+ session = loop.sessions.get_or_create(session_key, skip_heartbeat=True)+ session.add_message(+ "assistant",+ "hello",+ sender_id="user-1",+ response_id="resp-123",+ timestamp="2026-04-30T00:00:00",+ )+ await loop.sessions.save(session)++ await loop._process_message(+ InboundMessage(+ session_key=session_key,+ sender_id="user-1",+ content="that did not help",+ timestamp=datetime.fromisoformat("2026-04-30T00:05:00"),+ )+ )++ outcome_event = await bus.consume_outbound()+ assert outcome_event.event_type == OutboundEventType.RESPONSE_OUTCOME_EVALUATED+ assert outcome_event.response_id == "resp-123"+ persisted_session = loop.sessions.get_or_create(session_key, skip_heartbeat=True)+ assert persisted_session.metadata["response_outcomes"]["resp-123"]["outcome_label"] == "reasked"++@pytest.mark.asyncioasync def test_agent_loop_ignores_heartbeat_when_evaluating_previous_response_outcome(temp_dir: Path, monkeypatch@@ -132,6 +239,521 @@ async def test_agent_loop_ignores_heartbeat_when_evaluating_previous_response_ouassert "response_outcomes" not in persisted_session.metadata+async def test_agent_loop_build_prompt_history_uses_ov_context_plus_unsynced_tail(+ temp_dir: Path, monkeypatch+):+ monkeypatch.setattr(AgentLoop, "_register_builtin_hooks", lambda self: None)+ monkeypatch.setattr(AgentLoop, "_register_default_tools", lambda self: None)+ monkeypatch.setattr("vikingbot.agent.loop.SubagentManager", _FakeSubagentManager)++ fake_ov_client = _FakeOVClient(+ context_payload={+ "latest_archive_overview": "Earlier summary",+ "messages": [+ {"role": "user", "content": "OV user turn"},+ {"role": "assistant", "parts": [{"type": "text", "text": "OV assistant turn"}]},+ ],+ }+ )++ async def fake_get_ov_client(self, session_key):+ del session_key+ return fake_ov_client++ monkeypatch.setattr(AgentLoop, "_get_ov_client", fake_get_ov_client)++ bus = MessageBus()+ config = Config(+ storage_workspace=str(temp_dir),+ agents={"session_context_enabled": True, "session_context_token_budget": 321},+ )+ loop = AgentLoop(+ bus=bus,+ provider=_FakeProvider(),+ workspace=temp_dir / "workspace",+ config=config,+ )++ session_key = SessionKey(type="cli", channel_id="default", chat_id="session-ov-history")+ session = loop.sessions.get_or_create(session_key, skip_heartbeat=True)+ session.add_message("user", "local synced user")+ session.add_message("assistant", "local synced assistant")+ session.add_message("user", "local unsynced user")+ session.add_message("assistant", "local unsynced assistant")+ session.metadata["openviking"] = {+ "session_id": "ov-session-1",+ "last_synced_local_index": 1,+ }++ history = await loop._build_prompt_history(session)++ assert fake_ov_client.context_calls == [("ov-session-1", 321)]+ assert [message["content"] for message in history] == [+ "[Earlier conversation summary]\nEarlier summary",+ "OV user turn",+ "OV assistant turn",+ "local unsynced user",+ "local unsynced assistant",+ ]+++async def test_agent_loop_build_prompt_history_skips_tail_when_sync_cursor_is_past_local_messages(+ temp_dir: Path, monkeypatch+):+ monkeypatch.setattr(AgentLoop, "_register_builtin_hooks", lambda self: None)+ monkeypatch.setattr(AgentLoop, "_register_default_tools", lambda self: None)+ monkeypatch.setattr("vikingbot.agent.loop.SubagentManager", _FakeSubagentManager)++ fake_ov_client = _FakeOVClient(+ context_payload={"messages": [{"role": "user", "content": "OV user turn"}]}+ )++ async def fake_get_ov_client(self, session_key):+ del self, session_key+ return fake_ov_client++ monkeypatch.setattr(AgentLoop, "_get_ov_client", fake_get_ov_client)++ bus = MessageBus()+ config = Config(+ storage_workspace=str(temp_dir),+ agents={"session_context_enabled": True, "session_context_token_budget": 321},+ )+ loop = AgentLoop(+ bus=bus,+ provider=_FakeProvider(),+ workspace=temp_dir / "workspace",+ config=config,+ )++ session_key = SessionKey(type="cli", channel_id="default", chat_id="session-ov-cursor-past")+ session = loop.sessions.get_or_create(session_key, skip_heartbeat=True)+ session.add_message("user", "local user")+ session.add_message("assistant", "local assistant")+ session.metadata["openviking"] = {+ "session_id": "ov-session-1",+ "last_synced_local_index": 20,+ }++ history = await loop._build_prompt_history(session)++ assert [message["content"] for message in history] == ["OV user turn"]+++async def test_agent_loop_submits_openviking_session_through_compact_hook(+ temp_dir: Path, monkeypatch+):+ monkeypatch.setattr(AgentLoop, "_register_builtin_hooks", lambda self: None)+ monkeypatch.setattr(AgentLoop, "_register_default_tools", lambda self: None)+ monkeypatch.setattr("vikingbot.agent.loop.SubagentManager", _FakeSubagentManager)++ calls = []++ async def fake_execute_hooks(context, **kwargs):+ calls.append((context, kwargs))+ session = kwargs["session"]+ session.metadata.setdefault("openviking", {})["last_sync_status"] = "success"+ return kwargs++ monkeypatch.setattr(loop_module.hook_manager, "execute_hooks", fake_execute_hooks)++ bus = MessageBus()+ config = Config(+ storage_workspace=str(temp_dir),+ agents={"session_context_enabled": True},+ )+ loop = AgentLoop(+ bus=bus,+ provider=_FakeProvider(),+ workspace=temp_dir / "workspace",+ config=config,+ )++ session_key = SessionKey(type="cli", channel_id="default", chat_id="session-ov-sync")+ session = loop.sessions.get_or_create(session_key, skip_heartbeat=True)+ session.add_message("user", "Need syncing", sender_id="user-1")+ session.add_message("assistant", "Synced reply", sender_id="user-1")++ success = await loop._submit_openviking_session(session)++ assert success is True+ assert len(calls) == 1+ context, kwargs = calls[0]+ assert context.event_type == "message.compact"+ assert context.session_id == session_key.safe_name()+ assert kwargs == {"session": session, "force_commit": False}+++async def test_agent_loop_commits_openviking_before_model_when_pending_tokens_reach_threshold(+ temp_dir: Path, monkeypatch+):+ monkeypatch.setattr(AgentLoop, "_register_builtin_hooks", lambda self: None)+ monkeypatch.setattr(AgentLoop, "_register_default_tools", lambda self: None)+ monkeypatch.setattr("vikingbot.agent.loop.SubagentManager", _FakeSubagentManager)++ events = []++ async def fake_execute_hooks(context, **kwargs):+ events.append(+ (+ "hook",+ kwargs["force_commit"],+ kwargs.get("keep_recent_count"),+ kwargs.get("commit_message_threshold"),+ )+ )+ session = kwargs["session"]+ state = session.metadata.setdefault("openviking", {})+ state["last_sync_status"] = "success"+ state["last_pending_tokens"] = 0+ state["last_commit_performed"] = bool(kwargs["force_commit"])+ if not kwargs["force_commit"]:+ state["last_synced_local_index"] = len(session.messages) - 1+ return kwargs++ async def fake_get_ov_client(self, session_key):+ del self, session_key++ class _Client:+ async def get_session_context(self, session_id, token_budget):+ events.append(("context", session_id, token_budget))+ return {"messages": []}++ return _Client()++ async def fake_run_agent_loop(self, **kwargs):+ events.append(("model", [message.get("content") for message in kwargs["messages"]]))+ return "final answer", None, [], {"prompt_tokens": 1, "completion_tokens": 1}, 1++ fake_langfuse = _FakeLangfuseClient()+ monkeypatch.setattr(loop_module.hook_manager, "execute_hooks", fake_execute_hooks)+ monkeypatch.setattr(AgentLoop, "_get_ov_client", fake_get_ov_client)+ monkeypatch.setattr(AgentLoop, "_run_agent_loop", fake_run_agent_loop)+ monkeypatch.setattr(+ "vikingbot.agent.loop.LangfuseClient.get_instance",+ staticmethod(lambda: fake_langfuse),+ )++ bus = MessageBus()+ config = Config(+ storage_workspace=str(temp_dir),+ agents={+ "session_context_enabled": True,+ "session_context_token_budget": 321,+ "commit_token_threshold": 100,+ "commit_keep_recent_count": 2,+ },+ )+ loop = AgentLoop(+ bus=bus,+ provider=_FakeProvider(),+ workspace=temp_dir / "workspace",+ config=config,+ )++ session_key = SessionKey(type="cli", channel_id="default", chat_id="session-precommit")+ session = loop.sessions.get_or_create(session_key, skip_heartbeat=True)+ session.add_message("user", "old user", sender_id="user-1")+ session.add_message("assistant", "old assistant", sender_id="user-1")+ session.metadata["openviking"] = {+ "session_id": session_key.safe_name(),+ "last_synced_local_index": 1,+ "last_pending_tokens": 100,+ }+ await loop.sessions.save(session)++ response = await loop._process_message(+ InboundMessage(+ session_key=session_key,+ sender_id="user-1",+ content="new question",+ timestamp=datetime.fromisoformat("2026-04-30T00:05:00"),+ )+ )++ assert response is not None+ assert response.content == "final answer"+ assert events[0] == ("hook", True, 2, loop.memory_window)+ assert events[1] == ("context", "cli__default__session-precommit", 321)+ assert events[2][0] == "model"+ assert events[-1] == ("hook", False, None, loop.memory_window)+ persisted_session = loop.sessions.get_or_create(session_key, skip_heartbeat=True)+ assert [message["content"] for message in persisted_session.messages] == [+ "new question",+ "final answer",+ ]+ assert persisted_session.metadata["openviking"]["last_synced_local_index"] == 1+++async def test_agent_loop_commits_openviking_before_model_when_memory_window_reached(+ temp_dir: Path, monkeypatch+):+ monkeypatch.setattr(AgentLoop, "_register_builtin_hooks", lambda self: None)+ monkeypatch.setattr(AgentLoop, "_register_default_tools", lambda self: None)+ monkeypatch.setattr("vikingbot.agent.loop.SubagentManager", _FakeSubagentManager)++ events = []++ async def fake_execute_hooks(context, **kwargs):+ events.append(+ (+ "hook",+ kwargs["force_commit"],+ kwargs.get("keep_recent_count"),+ kwargs.get("commit_message_threshold"),+ )+ )+ session = kwargs["session"]+ session.metadata.setdefault("openviking", {})["last_sync_status"] = "success"+ session.metadata["openviking"]["last_pending_tokens"] = 0+ session.metadata["openviking"]["last_commit_local_index"] = len(session.messages) - 1+ session.metadata["openviking"]["last_commit_performed"] = bool(kwargs["force_commit"])+ return kwargs++ async def fake_get_ov_client(self, session_key):+ del self, session_key++ class _Client:+ async def get_session_context(self, session_id, token_budget):+ events.append(("context", session_id, token_budget))+ return {"messages": []}++ return _Client()++ async def fake_run_agent_loop(self, **kwargs):+ events.append(("model", [message.get("content") for message in kwargs["messages"]]))+ return "final answer", None, [], {"prompt_tokens": 1, "completion_tokens": 1}, 1++ fake_langfuse = _FakeLangfuseClient()+ monkeypatch.setattr(loop_module.hook_manager, "execute_hooks", fake_execute_hooks)+ monkeypatch.setattr(AgentLoop, "_get_ov_client", fake_get_ov_client)+ monkeypatch.setattr(AgentLoop, "_run_agent_loop", fake_run_agent_loop)+ monkeypatch.setattr(+ "vikingbot.agent.loop.LangfuseClient.get_instance",+ staticmethod(lambda: fake_langfuse),+ )++ bus = MessageBus()+ config = Config(+ storage_workspace=str(temp_dir),+ agents={+ "session_context_enabled": True,+ "session_context_token_budget": 321,+ "commit_token_threshold": 1000,+ "commit_keep_recent_count": 2,+ },+ )+ loop = AgentLoop(+ bus=bus,+ provider=_FakeProvider(),+ workspace=temp_dir / "workspace",+ config=config,+ memory_window=3,+ )++ session_key = SessionKey(type="cli", channel_id="default", chat_id="session-window-precommit")+ session = loop.sessions.get_or_create(session_key, skip_heartbeat=True)+ session.add_message("user", "old user", sender_id="user-1")+ session.add_message("assistant", "old assistant", sender_id="user-1")+ session.metadata["openviking"] = {+ "session_id": session_key.safe_name(),+ "last_synced_local_index": 1,+ "last_pending_tokens": 0,+ "last_commit_local_index": -1,+ }+ await loop.sessions.save(session)++ response = await loop._process_message(+ InboundMessage(+ session_key=session_key,+ sender_id="user-1",+ content="new question",+ timestamp=datetime.fromisoformat("2026-04-30T00:05:00"),+ )+ )++ assert response is not None+ assert response.content == "final answer"+ assert events[0] == ("hook", True, 2, 3)+ assert events[-1] == ("hook", False, None, 3)+ persisted_session = loop.sessions.get_or_create(session_key, skip_heartbeat=True)+ assert [message["content"] for message in persisted_session.messages] == [+ "new question",+ "final answer",+ ]+++async def test_agent_loop_does_not_precommit_again_after_memory_window_commit(+ temp_dir: Path, monkeypatch+):+ monkeypatch.setattr(AgentLoop, "_register_builtin_hooks", lambda self: None)+ monkeypatch.setattr(AgentLoop, "_register_default_tools", lambda self: None)+ monkeypatch.setattr("vikingbot.agent.loop.SubagentManager", _FakeSubagentManager)++ calls = []++ async def fake_execute_hooks(context, **kwargs):+ calls.append(kwargs)+ session = kwargs["session"]+ session.metadata.setdefault("openviking", {})["last_sync_status"] = "success"+ return kwargs++ monkeypatch.setattr(loop_module.hook_manager, "execute_hooks", fake_execute_hooks)++ bus = MessageBus()+ config = Config(+ storage_workspace=str(temp_dir),+ agents={+ "session_context_enabled": True,+ "commit_token_threshold": 1000,+ "commit_keep_recent_count": 2,+ },+ )+ loop = AgentLoop(+ bus=bus,+ provider=_FakeProvider(),+ workspace=temp_dir / "workspace",+ config=config,+ memory_window=3,+ )++ session_key = SessionKey(type="cli", channel_id="default", chat_id="session-window-no-repeat")+ session = loop.sessions.get_or_create(session_key, skip_heartbeat=True)+ session.add_message("user", "old user", sender_id="user-1")+ session.add_message("assistant", "old assistant", sender_id="user-1")+ session.metadata["openviking"] = {+ "session_id": session_key.safe_name(),+ "last_pending_tokens": 0,+ "last_commit_local_index": 1,+ }++ await loop._maybe_commit_openviking_before_turn(+ session,+ InboundMessage(+ session_key=session_key,+ sender_id="user-1",+ content="new question",+ timestamp=datetime.fromisoformat("2026-04-30T00:05:00"),+ ),+ )++ assert calls == []+++async def test_agent_loop_post_turn_passes_memory_window_threshold(temp_dir: Path, monkeypatch):+ monkeypatch.setattr(AgentLoop, "_register_builtin_hooks", lambda self: None)+ monkeypatch.setattr(AgentLoop, "_register_default_tools", lambda self: None)+ monkeypatch.setattr("vikingbot.agent.loop.SubagentManager", _FakeSubagentManager)++ calls = []++ async def fake_execute_hooks(context, **kwargs):+ calls.append(kwargs)+ session = kwargs["session"]+ session.metadata.setdefault("openviking", {})["last_sync_status"] = "success"+ return kwargs++ async def fake_run_agent_loop(self, **kwargs):+ return "final answer", None, [], {"prompt_tokens": 1, "completion_tokens": 1}, 1++ fake_langfuse = _FakeLangfuseClient()+ monkeypatch.setattr(loop_module.hook_manager, "execute_hooks", fake_execute_hooks)+ monkeypatch.setattr(AgentLoop, "_run_agent_loop", fake_run_agent_loop)+ monkeypatch.setattr(+ "vikingbot.agent.loop.LangfuseClient.get_instance",+ staticmethod(lambda: fake_langfuse),+ )++ bus = MessageBus()+ config = Config(storage_workspace=str(temp_dir), agents={"session_context_enabled": True})+ loop = AgentLoop(+ bus=bus,+ provider=_FakeProvider(),+ workspace=temp_dir / "workspace",+ config=config,+ memory_window=3,+ )++ session_key = SessionKey(type="cli", channel_id="default", chat_id="session-post-window")+ await loop._process_message(+ InboundMessage(+ session_key=session_key,+ sender_id="user-1",+ content="new question",+ timestamp=datetime.fromisoformat("2026-04-30T00:05:00"),+ )+ )++ assert calls[-1]["force_commit"] is False+ assert calls[-1]["commit_message_threshold"] == 3+++async def test_agent_loop_post_turn_clears_local_session_after_openviking_commit(+ temp_dir: Path, monkeypatch+):+ monkeypatch.setattr(AgentLoop, "_register_builtin_hooks", lambda self: None)+ monkeypatch.setattr(AgentLoop, "_register_default_tools", lambda self: None)+ monkeypatch.setattr("vikingbot.agent.loop.SubagentManager", _FakeSubagentManager)++ calls = []++ async def fake_execute_hooks(context, **kwargs):+ calls.append(kwargs)+ session = kwargs["session"]+ state = session.metadata.setdefault("openviking", {})+ state["last_sync_status"] = "success"+ state["last_commit_performed"] = True+ state["last_synced_local_index"] = len(session.messages) - 1+ state["last_commit_local_index"] = len(session.messages) - 1+ return kwargs++ async def fake_run_agent_loop(self, **kwargs):+ return "final answer", None, [], {"prompt_tokens": 1, "completion_tokens": 1}, 1++ fake_langfuse = _FakeLangfuseClient()+ monkeypatch.setattr(loop_module.hook_manager, "execute_hooks", fake_execute_hooks)+ monkeypatch.setattr(AgentLoop, "_run_agent_loop", fake_run_agent_loop)+ monkeypatch.setattr(+ "vikingbot.agent.loop.LangfuseClient.get_instance",+ staticmethod(lambda: fake_langfuse),+ )++ bus = MessageBus()+ config = Config(storage_workspace=str(temp_dir), agents={"session_context_enabled": True})+ loop = AgentLoop(+ bus=bus,+ provider=_FakeProvider(),+ workspace=temp_dir / "workspace",+ config=config,+ memory_window=3,+ )++ session_key = SessionKey(type="cli", channel_id="default", chat_id="session-post-clear")+ await loop._process_message(+ InboundMessage(+ session_key=session_key,+ sender_id="user-1",+ content="new question",+ timestamp=datetime.fromisoformat("2026-04-30T00:05:00"),+ )+ )++ persisted_session = loop.sessions.get_or_create(session_key, skip_heartbeat=True)+ assert calls[-1]["commit_message_threshold"] == 3+ assert persisted_session.messages == []+ assert persisted_session.metadata["openviking"]["session_id"] == session_key.safe_name()+ assert persisted_session.metadata["openviking"]["last_synced_local_index"] == -1+ assert persisted_session.metadata["openviking"]["last_commit_local_index"] == -1++@pytest.mark.asyncioasync def test_agent_loop_emits_normalized_response_completed_payload(temp_dir: Path, monkeypatch):monkeypatch.setattr(AgentLoop, "_register_builtin_hooks", lambda self: None)diff --git a/bot/tests/test_openviking_api_key_type.py b/bot/tests/test_openviking_api_key_type.pyindex 3579e8400..c3d2b4e82 100644--- a/bot/tests/test_openviking_api_key_type.py+++ b/bot/tests/test_openviking_api_key_type.py@@ -8,6 +8,8 @@ from vikingbot.hooks.base import HookContextfrom vikingbot.hooks.builtins.openviking_hooks import OpenVikingCompactHookfrom vikingbot.openviking_mount import ov_server as ov_server_modulefrom vikingbot.openviking_mount.ov_server import VikingClient+from vikingbot.openviking_mount.session_state import reset_openviking_state+from vikingbot.session.manager import SessionManagerclass _DummySession:@@ -28,8 +30,24 @@ class _DummyHTTPClient:async def initialize(self):return None- async def create_session(self):- return {"session_id": "s-1"}+ async def create_session(self, session_id=None):+ return {"session_id": session_id or "s-1"}++ async def session_exists(self, _session_id):+ return False++ async def get_session(self, session_id):+ return {"session_id": session_id, "pending_tokens": 0}++ async def batch_add_messages(self, session_id, messages):+ return {"session_id": session_id, "added": len(messages), "message_count": len(messages)}++ async def commit_session(self, session_id, keep_recent_count=0, telemetry=False):+ return {+ "session_id": session_id,+ "status": "committed",+ "keep_recent_count": keep_recent_count,+ }def session(self, _session_id):return _DummySession()@@ -37,6 +55,15 @@ class _DummyHTTPClient:async def admin_list_accounts(self):return []+ async def admin_list_users(self, _account_id):+ return []++ async def admin_register_user(self, account_id, user_id, role="user"):+ return {"account_id": account_id, "user_id": user_id, "role": role}++ async def admin_remove_user(self, _account_id, _user_id):+ return None+async def find(self, *_args, **_kwargs):return []@@ -50,7 +77,18 @@ class _DummyHTTPClient:return None-def _make_config(api_key_type: str, mode: str = "remote"):+def _make_config(api_key_type: str, mode: str = "remote", **ov_overrides):+ agent_defaults = {+ "session_context_enabled": False,+ "session_context_token_budget": 12000,+ "commit_token_threshold": 6000,+ "commit_keep_recent_count": 10,+ }+ agent_overrides = {}+ for key in tuple(agent_defaults):+ if key in ov_overrides:+ agent_overrides[key] = ov_overrides.pop(key)+ agents = SimpleNamespace(**{**agent_defaults, **agent_overrides})ov_server = SimpleNamespace(mode=mode,api_key_type=api_key_type,@@ -59,8 +97,11 @@ def _make_config(api_key_type: str, mode: str = "remote"):account_id="acct",admin_user_id="admin",agent_id="",+ **ov_overrides,+ )+ return SimpleNamespace(+ ov_server=ov_server, agents=agents, ov_data_path=Path("/tmp/openviking-test"))- return SimpleNamespace(ov_server=ov_server, ov_data_path=Path("/tmp/openviking-test"))@pytest.fixture(autouse=True)@@ -110,7 +151,7 @@ async def test_commit_user_mode_ignores_user_specific_key_flow(monkeypatch):user_id="sender-1",)- assert result["success"] == "committed"+ assert result["success"] is True@pytest.mark.asyncio@@ -134,7 +175,7 @@ async def test_commit_root_mode_uses_sender_user_key(monkeypatch):user_id="sender-2",)- assert result["success"] == "committed"+ assert result["success"] is Trueassert any(inst.kwargs.get("api_key") == "user-key-1" for inst in _DummyHTTPClient.instances)@@ -186,7 +227,705 @@ async def test_compact_hook_user_mode_commits_once(monkeypatch):@pytest.mark.asyncio-async def test_search_memory_uses_flat_agent_namespace_by_default(monkeypatch):+async def test_compact_hook_session_context_commits_admin_and_sender_sessions(monkeypatch):+ from vikingbot.hooks.builtins import openviking_hooks as hooks_module++ monkeypatch.setattr(+ hooks_module,+ "load_config",+ lambda: _make_config(+ "root",+ session_context_enabled=True,+ commit_token_threshold=100,+ commit_keep_recent_count=2,+ ),+ )++ class _FakeClient:+ def __init__(self):+ self.pending_tokens = [120, 0]+ self.append_calls = []+ self.session_calls = []+ self.commit_calls = []++ async def append_messages(+ self,+ session_id,+ messages,+ default_user_role_id=None,+ session_user_id=None,+ ):+ self.append_calls.append(+ (+ session_id,+ [message["content"] for message in messages],+ default_user_role_id,+ session_user_id,+ )+ )+ return {"session_id": session_id, "added": len(messages)}++ async def get_session(self, session_id, user_id=None):+ self.session_calls.append((session_id, user_id))+ pending_tokens = self.pending_tokens.pop(0) if self.pending_tokens else 0+ return {"session_id": session_id, "pending_tokens": pending_tokens}++ async def commit_session(self, session_id, keep_recent_count=0, user_id=None):+ self.commit_calls.append((session_id, keep_recent_count, user_id))+ return {"session_id": session_id, "status": "accepted"}++ fake_client = _FakeClient()+ hook = OpenVikingCompactHook()++ async def _fake_get_client(_workspace_id):+ return fake_client++ monkeypatch.setattr(hook, "_get_client", _fake_get_client)++ context = HookContext(+ event_type="message.compact",+ workspace_id="ws",+ session_key=SessionKey(type="cli", channel_id="default", chat_id="chat-1"),+ )+ session = SimpleNamespace(+ messages=[+ {"sender_id": "admin", "role": "assistant", "content": "admin answer"},+ {"sender_id": "u1", "role": "user", "content": "u1 asks"},+ {"sender_id": "u1", "role": "assistant", "content": "u1 reply"},+ {"sender_id": "u2", "role": "user", "content": "u2 asks"},+ ],+ metadata={},+ )++ result = await hook.execute(context, session=session)++ assert result["success"] is True+ assert result["admin_result"]["committed"] is True+ assert result["users_count"] == 2+ assert fake_client.append_calls[-1] == (+ "cli__default__chat-1",+ ["admin answer", "u1 asks", "u1 reply", "u2 asks"],+ "admin",+ "admin",+ )+ assert (+ "cli__default__chat-1_u1",+ ["u1 asks", "u1 reply"],+ "u1",+ "u1",+ ) in fake_client.append_calls+ assert ("cli__default__chat-1_u2", ["u2 asks"], "u2", "u2") in fake_client.append_calls+ assert ("cli__default__chat-1", 2, "admin") in fake_client.commit_calls+ assert ("cli__default__chat-1_u1", 2, "u1") in fake_client.commit_calls+ assert ("cli__default__chat-1_u2", 2, "u2") in fake_client.commit_calls++ state = session.metadata["openviking"]+ assert state["session_id"] == "cli__default__chat-1"+ assert state["last_synced_local_index"] == len(session.messages) - 1+ assert state["last_pending_tokens"] == 0+ assert state["last_sync_status"] == "success"+ assert state["last_commit_local_index"] == len(session.messages) - 1+ assert "last_commit_at" in state+++async def test_reset_openviking_state_replaces_persisted_sender_cursors(temp_dir):+ manager = SessionManager(temp_dir / "bot")+ session_key = SessionKey(type="cli", channel_id="default", chat_id="chat-1")+ session = manager.get_or_create(session_key, skip_heartbeat=True)+ session.metadata["openviking"] = {+ "session_id": session_key.safe_name(),+ "last_synced_local_index": 19,+ "last_sender_synced_local_indexes": {"user-1": 19},+ "last_pending_tokens": 100,+ "last_commit_local_index": 19,+ "last_commit_performed": True,+ "last_sync_error": "old error",+ }+ await manager.save(session)++ session.clear()+ reset_openviking_state(session)+ await manager.save(session)++ manager._cache.clear()+ persisted_session = manager.get_or_create(session_key, skip_heartbeat=True)+ state = persisted_session.metadata["openviking"]+ assert state == {+ "session_id": session_key.safe_name(),+ "last_synced_local_index": -1,+ "last_sender_synced_local_indexes": {},+ "last_pending_tokens": 0,+ "last_commit_local_index": -1,+ "last_sync_status": "reset",+ }+ assert persisted_session.messages == []+++async def test_compact_hook_force_commit_does_not_resync_already_synced_messages(monkeypatch):+ from vikingbot.hooks.builtins import openviking_hooks as hooks_module++ monkeypatch.setattr(+ hooks_module,+ "load_config",+ lambda: _make_config(+ "root",+ session_context_enabled=True,+ commit_token_threshold=100,+ commit_keep_recent_count=2,+ ),+ )++ class _FakeClient:+ def __init__(self):+ self.append_calls = []+ self.commit_calls = []++ async def append_messages(+ self,+ session_id,+ messages,+ default_user_role_id=None,+ session_user_id=None,+ ):+ self.append_calls.append((session_id, [message["content"] for message in messages]))+ return {"session_id": session_id, "added": len(messages)}++ async def get_session(self, session_id, user_id=None):+ return {"session_id": session_id, "pending_tokens": 120}++ async def commit_session(self, session_id, keep_recent_count=0, user_id=None):+ self.commit_calls.append((session_id, keep_recent_count, user_id))+ return {"session_id": session_id, "status": "accepted"}++ fake_client = _FakeClient()+ hook = OpenVikingCompactHook()++ async def _fake_get_client(_workspace_id):+ return fake_client++ monkeypatch.setattr(hook, "_get_client", _fake_get_client)++ context = HookContext(+ event_type="message.compact",+ workspace_id="ws",+ session_key=SessionKey(type="cli", channel_id="default", chat_id="chat-1"),+ )+ session = SimpleNamespace(+ messages=[+ {"sender_id": "u1", "role": "user", "content": "already synced"},+ {"sender_id": "u1", "role": "assistant", "content": "new reply"},+ ],+ metadata={+ "openviking": {+ "session_id": "cli__default__chat-1",+ "last_synced_local_index": 0,+ "last_pending_tokens": 120,+ }+ },+ )++ result = await hook.execute(context, session=session, force_commit=True)++ assert result["success"] is True+ assert fake_client.append_calls == [+ ("cli__default__chat-1_u1", ["new reply"]),+ ("cli__default__chat-1", ["new reply"]),+ ]+ assert ("cli__default__chat-1", 2, "admin") in fake_client.commit_calls+ assert ("cli__default__chat-1_u1", 2, "u1") in fake_client.commit_calls+ assert session.metadata["openviking"]["last_synced_local_index"] == 1+ assert session.metadata["openviking"]["last_commit_local_index"] == 1+++async def test_compact_hook_force_commit_commits_sender_sessions_without_unsynced_messages(+ monkeypatch,+):+ from vikingbot.hooks.builtins import openviking_hooks as hooks_module++ monkeypatch.setattr(+ hooks_module,+ "load_config",+ lambda: _make_config(+ "root",+ session_context_enabled=True,+ commit_token_threshold=1000,+ commit_keep_recent_count=2,+ ),+ )++ class _FakeClient:+ def __init__(self):+ self.append_calls = []+ self.commit_calls = []++ async def append_messages(+ self,+ session_id,+ messages,+ default_user_role_id=None,+ session_user_id=None,+ ):+ self.append_calls.append((session_id, [message["content"] for message in messages]))+ return {"session_id": session_id, "added": len(messages)}++ async def get_session(self, session_id, user_id=None):+ return {"session_id": session_id, "pending_tokens": 120}++ async def commit_session(self, session_id, keep_recent_count=0, user_id=None):+ self.commit_calls.append((session_id, keep_recent_count, user_id))+ return {"session_id": session_id, "status": "accepted"}++ fake_client = _FakeClient()+ hook = OpenVikingCompactHook()++ async def _fake_get_client(_workspace_id):+ return fake_client++ monkeypatch.setattr(hook, "_get_client", _fake_get_client)++ context = HookContext(+ event_type="message.compact",+ workspace_id="ws",+ session_key=SessionKey(type="cli", channel_id="default", chat_id="chat-1"),+ )+ session = SimpleNamespace(+ messages=[+ {"sender_id": "u1", "role": "user", "content": "already synced"},+ {"sender_id": "u2", "role": "user", "content": "also synced"},+ ],+ metadata={+ "openviking": {+ "session_id": "cli__default__chat-1",+ "last_synced_local_index": 1,+ "last_pending_tokens": 120,+ }+ },+ )++ result = await hook.execute(context, session=session, force_commit=True)++ assert result["success"] is True+ assert fake_client.append_calls == []+ assert ("cli__default__chat-1", 2, "admin") in fake_client.commit_calls+ assert ("cli__default__chat-1_u1", 2, "u1") in fake_client.commit_calls+ assert ("cli__default__chat-1_u2", 2, "u2") in fake_client.commit_calls+ assert session.metadata["openviking"]["last_commit_performed"] is True+++async def test_compact_hook_session_context_sender_failure_does_not_advance_sync_cursor(+ monkeypatch,+):+ from vikingbot.hooks.builtins import openviking_hooks as hooks_module++ monkeypatch.setattr(+ hooks_module,+ "load_config",+ lambda: _make_config(+ "root",+ session_context_enabled=True,+ commit_token_threshold=100,+ commit_keep_recent_count=2,+ ),+ )++ class _FakeClient:+ def __init__(self):+ self.append_calls = []+ self.commit_calls = []++ async def append_messages(+ self,+ session_id,+ messages,+ default_user_role_id=None,+ session_user_id=None,+ ):+ self.append_calls.append((session_id, [message["content"] for message in messages]))+ if session_id.endswith("_u1"):+ raise RuntimeError("sender append failed")+ return {"session_id": session_id, "added": len(messages)}++ async def get_session(self, session_id, user_id=None):+ return {"session_id": session_id, "pending_tokens": 120}++ async def commit_session(self, session_id, keep_recent_count=0, user_id=None):+ self.commit_calls.append((session_id, keep_recent_count, user_id))+ return {"session_id": session_id, "status": "accepted"}++ fake_client = _FakeClient()+ hook = OpenVikingCompactHook()++ async def _fake_get_client(_workspace_id):+ return fake_client++ monkeypatch.setattr(hook, "_get_client", _fake_get_client)++ context = HookContext(+ event_type="message.compact",+ workspace_id="ws",+ session_key=SessionKey(type="cli", channel_id="default", chat_id="chat-1"),+ )+ session = SimpleNamespace(+ messages=[+ {"sender_id": "u1", "role": "user", "content": "u1 asks"},+ {"sender_id": "u1", "role": "assistant", "content": "u1 reply"},+ ],+ metadata={+ "openviking": {"session_id": "cli__default__chat-1", "last_synced_local_index": -1}+ },+ )++ result = await hook.execute(context, session=session)++ assert result["success"] is False+ assert "sender append failed" in result["error"]+ assert fake_client.append_calls == [("cli__default__chat-1_u1", ["u1 asks", "u1 reply"])]+ assert fake_client.commit_calls == []+ state = session.metadata["openviking"]+ assert state["last_sync_status"] == "error"+ assert "sender append failed" in state["last_sync_error"]+ assert state["last_synced_local_index"] == -1+ assert state["last_commit_performed"] is False+++async def test_compact_hook_session_context_commits_when_message_threshold_reached(+ monkeypatch,+):+ from vikingbot.hooks.builtins import openviking_hooks as hooks_module++ monkeypatch.setattr(+ hooks_module,+ "load_config",+ lambda: _make_config(+ "root",+ session_context_enabled=True,+ commit_token_threshold=1000,+ commit_keep_recent_count=2,+ ),+ )++ class _FakeClient:+ def __init__(self):+ self.append_calls = []+ self.commit_calls = []++ async def append_messages(+ self,+ session_id,+ messages,+ default_user_role_id=None,+ session_user_id=None,+ ):+ self.append_calls.append((session_id, [message["content"] for message in messages]))+ return {"session_id": session_id, "added": len(messages)}++ async def get_session(self, session_id, user_id=None):+ return {"session_id": session_id, "pending_tokens": 0}++ async def commit_session(self, session_id, keep_recent_count=0, user_id=None):+ self.commit_calls.append((session_id, keep_recent_count, user_id))+ return {"session_id": session_id, "status": "accepted"}++ fake_client = _FakeClient()+ hook = OpenVikingCompactHook()++ async def _fake_get_client(_workspace_id):+ return fake_client++ monkeypatch.setattr(hook, "_get_client", _fake_get_client)++ context = HookContext(+ event_type="message.compact",+ workspace_id="ws",+ session_key=SessionKey(type="cli", channel_id="default", chat_id="chat-1"),+ )+ session = SimpleNamespace(+ messages=[+ {"sender_id": "u1", "role": "user", "content": "m1"},+ {"sender_id": "u1", "role": "assistant", "content": "m2"},+ {"sender_id": "u1", "role": "user", "content": "m3"},+ ],+ metadata={+ "openviking": {+ "session_id": "cli__default__chat-1",+ "last_synced_local_index": 1,+ "last_pending_tokens": 0,+ "last_commit_local_index": -1,+ }+ },+ )++ result = await hook.execute(context, session=session, commit_message_threshold=3)++ assert result["success"] is True+ assert result["admin_result"]["committed"] is True+ assert fake_client.append_calls == [+ ("cli__default__chat-1_u1", ["m3"]),+ ("cli__default__chat-1", ["m3"]),+ ]+ assert ("cli__default__chat-1", 2, "admin") in fake_client.commit_calls+ assert ("cli__default__chat-1_u1", 2, "u1") in fake_client.commit_calls+ assert session.metadata["openviking"]["last_commit_local_index"] == 2+++async def test_compact_hook_sender_commit_failure_does_not_commit_admin_and_retry_dedupes(+ monkeypatch,+):+ from vikingbot.hooks.builtins import openviking_hooks as hooks_module++ monkeypatch.setattr(+ hooks_module,+ "load_config",+ lambda: _make_config(+ "root",+ session_context_enabled=True,+ commit_token_threshold=100,+ commit_keep_recent_count=2,+ ),+ )++ class _FakeClient:+ def __init__(self):+ self.append_calls = []+ self.commit_calls = []+ self.fail_sender_commit = True++ async def append_messages(+ self,+ session_id,+ messages,+ default_user_role_id=None,+ session_user_id=None,+ ):+ self.append_calls.append((session_id, [message["content"] for message in messages]))+ return {"session_id": session_id, "added": len(messages)}++ async def get_session(self, session_id, user_id=None):+ return {"session_id": session_id, "pending_tokens": 120}++ async def commit_session(self, session_id, keep_recent_count=0, user_id=None):+ self.commit_calls.append((session_id, keep_recent_count, user_id))+ if session_id.endswith("_u1") and self.fail_sender_commit:+ raise RuntimeError("sender commit failed")+ return {"session_id": session_id, "status": "accepted"}++ fake_client = _FakeClient()+ hook = OpenVikingCompactHook()++ async def _fake_get_client(_workspace_id):+ return fake_client++ monkeypatch.setattr(hook, "_get_client", _fake_get_client)++ context = HookContext(+ event_type="message.compact",+ workspace_id="ws",+ session_key=SessionKey(type="cli", channel_id="default", chat_id="chat-1"),+ )+ session = SimpleNamespace(+ messages=[+ {"sender_id": "u1", "role": "user", "content": "u1 asks"},+ {"sender_id": "u1", "role": "assistant", "content": "u1 reply"},+ ],+ metadata={"openviking": {"session_id": "cli__default__chat-1"}},+ )++ first = await hook.execute(context, session=session)++ assert first["success"] is False+ assert "sender commit failed" in first["error"]+ assert fake_client.append_calls == [+ ("cli__default__chat-1_u1", ["u1 asks", "u1 reply"]),+ ("cli__default__chat-1", ["u1 asks", "u1 reply"]),+ ]+ assert fake_client.commit_calls == [("cli__default__chat-1_u1", 2, "u1")]+ state = session.metadata["openviking"]+ assert state["last_sync_status"] == "error"+ assert state["last_synced_local_index"] == 1+ assert state["last_sender_synced_local_indexes"] == {"u1": 1}+ assert state["last_commit_performed"] is False++ fake_client.fail_sender_commit = False+ fake_client.append_calls.clear()+ fake_client.commit_calls.clear()++ second = await hook.execute(context, session=session, force_commit=True)++ assert second["success"] is True+ assert fake_client.append_calls == []+ assert fake_client.commit_calls == [+ ("cli__default__chat-1_u1", 2, "u1"),+ ("cli__default__chat-1", 2, "admin"),+ ]+ assert session.metadata["openviking"]["last_commit_performed"] is True+++async def test_compact_hook_session_context_skips_message_threshold_after_recent_commit(+ monkeypatch,+):+ from vikingbot.hooks.builtins import openviking_hooks as hooks_module++ monkeypatch.setattr(+ hooks_module,+ "load_config",+ lambda: _make_config(+ "root",+ session_context_enabled=True,+ commit_token_threshold=1000,+ commit_keep_recent_count=2,+ ),+ )++ class _FakeClient:+ def __init__(self):+ self.append_calls = []+ self.commit_calls = []++ async def append_messages(+ self,+ session_id,+ messages,+ default_user_role_id=None,+ session_user_id=None,+ ):+ self.append_calls.append((session_id, [message["content"] for message in messages]))+ return {"session_id": session_id, "added": len(messages)}++ async def get_session(self, session_id, user_id=None):+ return {"session_id": session_id, "pending_tokens": 0}++ async def commit_session(self, session_id, keep_recent_count=0, user_id=None):+ self.commit_calls.append((session_id, keep_recent_count, user_id))+ return {"session_id": session_id, "status": "accepted"}++ fake_client = _FakeClient()+ hook = OpenVikingCompactHook()++ async def _fake_get_client(_workspace_id):+ return fake_client++ monkeypatch.setattr(hook, "_get_client", _fake_get_client)++ context = HookContext(+ event_type="message.compact",+ workspace_id="ws",+ session_key=SessionKey(type="cli", channel_id="default", chat_id="chat-1"),+ )+ session = SimpleNamespace(+ messages=[+ {"sender_id": "u1", "role": "user", "content": "m1"},+ {"sender_id": "u1", "role": "assistant", "content": "m2"},+ {"sender_id": "u1", "role": "user", "content": "m3"},+ ],+ metadata={+ "openviking": {+ "session_id": "cli__default__chat-1",+ "last_synced_local_index": 1,+ "last_pending_tokens": 0,+ "last_commit_local_index": 1,+ }+ },+ )++ result = await hook.execute(context, session=session, commit_message_threshold=3)++ assert result["success"] is True+ assert result["admin_result"]["committed"] is False+ assert fake_client.append_calls == [+ ("cli__default__chat-1_u1", ["m3"]),+ ("cli__default__chat-1", ["m3"]),+ ]+ assert fake_client.commit_calls == []+++async def test_viking_client_normalizes_system_tool_and_tool_result_messages(monkeypatch):+ monkeypatch.setattr(ov_server_module, "load_config", lambda: _make_config("root"))+ client = VikingClient(agent_id="workspace")++ normalized = client._normalize_session_messages(+ [+ {+ "role": "system",+ "content": "system context",+ "timestamp": "2026-05-01T12:00:00Z",+ },+ {+ "role": "tool",+ "content": "tool response",+ "timestamp": "2026-05-01T12:00:01Z",+ },+ {+ "role": "assistant",+ "content": "assistant answer",+ "tools_used": [+ {+ "tool_name": "read_file",+ "args": {"path": "README.md"},+ "result": "file content",+ }+ ],+ "timestamp": "2026-05-01T12:00:02Z",+ },+ ],+ default_user_role_id="admin",+ )++ assert [message["role"] for message in normalized] == [+ "assistant",+ "assistant",+ "assistant",+ ]+ assert [message["role_id"] for message in normalized] == [+ "workspace",+ "workspace",+ "workspace",+ ]+ assert normalized[0]["content"] == "system context"+ assert normalized[1]["content"] == "tool response"+ assert normalized[2]["content"] == "assistant answer"+++async def test_viking_client_append_messages_chunks_batches_at_server_limit(monkeypatch):+ monkeypatch.setattr(ov_server_module, "load_config", lambda: _make_config("root"))+ client = VikingClient(agent_id="workspace")++ async def _exists(_session_id):+ return True++ calls = []++ async def _batch_add_messages(session_id, messages):+ calls.append((session_id, list(messages)))+ return {+ "session_id": session_id,+ "added": len(messages),+ "message_count": sum(len(batch) for _, batch in calls),+ }++ monkeypatch.setattr(client.client, "session_exists", _exists)+ monkeypatch.setattr(client.client, "batch_add_messages", _batch_add_messages)++ result = await client.append_messages(+ "session-1",+ [{"role": "user", "content": f"message {index}"} for index in range(101)],+ default_user_role_id="admin",+ )++ assert [len(messages) for _, messages in calls] == [100, 1]+ assert result == {"session_id": "session-1", "added": 101, "message_count": 101}+++async def test_search_memory_uses_flat_namespaces(monkeypatch):monkeypatch.setattr(ov_server_module, "load_config", lambda: _make_config("root"))client = VikingClient(agent_id="workspace")@@ -247,7 +986,7 @@ async def test_search_memory_uses_policy_scoped_namespaces(monkeypatch):assert calls == ["viking://user/sender-1/agent/workspace/memories/",- "viking://agent/workspace/user/sender-1/memories/",+ "viking://agent/workspace/user/admin/memories/",]diff --git a/bot/vikingbot/agent/loop.py b/bot/vikingbot/agent/loop.pyindex d771eb349..3668083a4 100644--- a/bot/vikingbot/agent/loop.py+++ b/bot/vikingbot/agent/loop.py@@ -28,10 +28,17 @@ from vikingbot.hooks import HookContextfrom vikingbot.hooks.manager import hook_managerfrom vikingbot.integrations.langfuse import LangfuseClientfrom vikingbot.observability.outcome import evaluate_response_outcome, should_update_outcome+from vikingbot.openviking_mount.session_state import (+ get_openviking_session_id,+ get_openviking_state,+ get_unsynced_messages,+ parse_local_index,+ reset_openviking_state,+)from vikingbot.providers.base import LLMProviderfrom vikingbot.sandbox import SandboxManagerfrom vikingbot.session.manager import Session, SessionManager-from vikingbot.utils.helpers import cal_str_tokens+from vikingbot.utils.helpers import cal_str_tokens, ensure_non_empty_assistant_contentfrom vikingbot.utils.tracing import set_response_id, traceif TYPE_CHECKING:@@ -140,6 +147,7 @@ class AgentLoop:self._mcp_stack: AsyncExitStack | None = Noneself._mcp_connected = Falseself._mcp_connecting = False+ self._ov_clients: dict[str, Any] = {}self._register_default_tools()async def _connect_mcp(self) -> None:@@ -231,6 +239,247 @@ class AgentLoop:cron_service=self.cron_service,)+ def _ov_session_context_enabled(self) -> bool:+ agents_config = getattr(self.config, "agents", None)+ return bool(agents_config and getattr(agents_config, "session_context_enabled", False))++ def _get_ov_workspace_id(self, session_key: SessionKey) -> str:+ if self.sandbox_manager:+ return self.sandbox_manager.to_workspace_id(session_key)+ return "shared"++ async def _get_ov_client(self, session_key: SessionKey):+ workspace_id = self._get_ov_workspace_id(session_key)+ client = self._ov_clients.get(workspace_id)+ if client is None:+ from vikingbot.openviking_mount.ov_server import VikingClient++ client = await VikingClient.create(workspace_id)+ self._ov_clients[workspace_id] = client+ return client++ def _format_history_messages(+ self,+ session: Session,+ messages: list[dict[str, Any]],+ provider_name: str | None = None,+ ) -> list[dict[str, Any]]:+ if not messages:+ return []+ temp_session = Session(key=session.key, messages=list(messages), metadata=session.metadata)+ return temp_session.get_history(max_messages=len(messages), provider_name=provider_name)++ @staticmethod+ def _flatten_ov_message_text(message: dict[str, Any]) -> str:+ content = message.get("content")+ if isinstance(content, str) and content.strip():+ return content.strip()++ text_parts: list[str] = []+ for part in message.get("parts") or []:+ if not isinstance(part, dict):+ continue+ for key in ("text", "abstract", "tool_output"):+ value = part.get(key)+ if isinstance(value, str) and value.strip():+ text_parts.append(value.strip())+ return "\n".join(text_parts).strip()++ def _build_ov_history_messages(+ self,+ session: Session,+ context_payload: dict[str, Any],+ provider_name: str | None = None,+ ) -> list[dict[str, Any]]:+ raw_messages: list[dict[str, Any]] = []+ overview = str(context_payload.get("latest_archive_overview") or "").strip()+ if overview:+ raw_messages.append(+ {+ "role": "assistant",+ "content": ensure_non_empty_assistant_content(+ f"[Earlier conversation summary]\n{overview}"+ ),+ }+ )++ for message in context_payload.get("messages") or []:+ if not isinstance(message, dict):+ continue+ role = str(message.get("role") or "").strip().lower()+ if role not in {"user", "assistant"}:+ continue+ text = self._flatten_ov_message_text(message)+ if not text:+ continue+ raw_messages.append(+ {+ "role": role,+ "content": (+ ensure_non_empty_assistant_content(text) if role == "assistant" else text+ ),+ }+ )++ return self._format_history_messages(+ session,+ raw_messages,+ provider_name=provider_name,+ )++ async def _build_prompt_history(+ self,+ session: Session,+ provider_name: str | None = None,+ ) -> list[dict[str, Any]]:+ if not self._ov_session_context_enabled():+ return session.get_history(provider_name=provider_name)++ agents_config = getattr(self.config, "agents", None)+ token_budget = int(getattr(agents_config, "session_context_token_budget", 12000) or 12000)+ session_id = get_openviking_session_id(session)++ try:+ client = await self._get_ov_client(session.key)+ context_payload = await client.get_session_context(+ session_id=session_id,+ token_budget=token_budget,+ )+ ov_history = self._build_ov_history_messages(+ session,+ context_payload,+ provider_name=provider_name,+ )+ local_tail = self._format_history_messages(+ session,+ get_unsynced_messages(session),+ provider_name=provider_name,+ )+ return ov_history + local_tail+ except Exception as e:+ logger.warning(+ f"Failed to load OpenViking session context for {session_id}: {e}. "+ "Falling back to local session history."+ )+ return session.get_history(provider_name=provider_name)++ async def _submit_openviking_session(+ self,+ session: Session,+ *,+ force_commit: bool = False,+ keep_recent_count: int | None = None,+ commit_message_threshold: int | None = None,+ ) -> bool:+ if not self._ov_session_context_enabled():+ return False++ state = get_openviking_state(session)+ state.pop("last_commit_performed", None)+ kwargs: dict[str, Any] = {+ "session": session,+ "force_commit": force_commit,+ }+ if keep_recent_count is not None:+ kwargs["keep_recent_count"] = keep_recent_count+ if commit_message_threshold is not None:+ kwargs["commit_message_threshold"] = commit_message_threshold++ await hook_manager.execute_hooks(+ context=HookContext(+ event_type="message.compact",+ session_id=get_openviking_session_id(session),+ workspace_id=self._get_ov_workspace_id(session.key),+ session_key=session.key,+ ),+ **kwargs,+ )+ await self.sessions.save(session)+ return get_openviking_state(session).get("last_sync_status") == "success"++ async def _submit_openviking_session_and_clear_if_committed(+ self,+ session: Session,+ *,+ force_commit: bool = False,+ keep_recent_count: int | None = None,+ commit_message_threshold: int | None = None,+ ) -> bool:+ success = await self._submit_openviking_session(+ session,+ force_commit=force_commit,+ keep_recent_count=keep_recent_count,+ commit_message_threshold=commit_message_threshold,+ )+ if not success:+ return False+ if not get_openviking_state(session).get("last_commit_performed"):+ return True++ session.clear()+ reset_openviking_state(session, rotate_session_id=False)+ state = get_openviking_state(session)+ state["last_sync_status"] = "success"+ await self.sessions.save(session)+ return True++ async def _maybe_commit_openviking_before_turn(+ self,+ session: Session,+ msg: InboundMessage,+ ) -> None:+ if not self._ov_session_context_enabled():+ return++ agents_config = getattr(self.config, "agents", None)+ if agents_config is None:+ return++ state = get_openviking_state(session)+ pending_tokens = int(state.get("last_pending_tokens", 0) or 0)+ commit_token_threshold = int(getattr(agents_config, "commit_token_threshold", 6000) or 6000)+ incoming_tokens = cal_str_tokens(msg.content or "")+ last_commit_local_index = parse_local_index(state.get("last_commit_local_index", -1))+ messages_since_commit = len(session.messages) - last_commit_local_index - 1+ incoming_messages_count = 1+ should_commit = bool(+ pending_tokens >= commit_token_threshold+ or pending_tokens + incoming_tokens >= commit_token_threshold+ or messages_since_commit + incoming_messages_count >= self.memory_window+ )+ if not should_commit:+ return++ await self._submit_openviking_session_and_clear_if_committed(+ session,+ force_commit=True,+ keep_recent_count=int(getattr(agents_config, "commit_keep_recent_count", 10) or 0),+ commit_message_threshold=self.memory_window,+ )++ async def _commit_openviking_session(+ self,+ session: Session,+ *,+ keep_recent_count: int = 0,+ clear_local_session: bool = False,+ rotate_session_id: bool = False,+ ) -> bool:+ success = await self._submit_openviking_session(+ session,+ force_commit=True,+ keep_recent_count=keep_recent_count,+ )+ if not success:+ return False+ if clear_local_session:+ session.clear()+ reset_openviking_state(session, rotate_session_id=rotate_session_id)+ state = get_openviking_state(session)+ state["last_sync_status"] = "success"+ await self.sessions.save(session)+ return True+async def run(self) -> None:"""Run the agent loop, processing messages from the bus."""self._running = True@@ -346,20 +595,29 @@ class AgentLoop:try:# Build query from last 3 user messages_user_msgs = [- m["content"] for m in messages+ m["content"]+ for m in messagesif m.get("role") == "user" and isinstance(m.get("content"), str)]_query = "\n".join(_user_msgs[-3:])- workspace_id = self.sandbox_manager.to_workspace_id(session_key) if self.sandbox_manager else "shared"+ workspace_id = (+ self.sandbox_manager.to_workspace_id(session_key)+ if self.sandbox_manager+ else "shared"+ )_exp = await self.context.memory.get_viking_experience_context(query=_query, workspace_id=workspace_id)- logger.info(f"[WRITE_EXP]: write tool detected, exp_found={bool(_exp)}, query={_query[:50]}")+ logger.info(+ f"[WRITE_EXP]: write tool detected, exp_found={bool(_exp)}, query={_query[:50]}"+ )if _exp:- messages.append({- "role": "user",- "content": f"## Relevant Agent Experience\n{_exp}",- })+ messages.append(+ {+ "role": "user",+ "content": f"## Relevant Agent Experience\n{_exp}",+ }+ )continueexcept Exception as _e:logger.warning(f"[WRITE_EXP]: failed to load experience: {_e}")@@ -559,6 +817,8 @@ class AgentLoop:metadata=msg.metadata,)session.clear()+ if self._ov_session_context_enabled():+ reset_openviking_state(session, rotate_session_id=True)await self.sessions.save(session)return OutboundMessage(session_key=msg.session_key,@@ -573,11 +833,24 @@ class AgentLoop:content="🐈 Sorry, you are not authorized to use this command.",metadata=msg.metadata,)- session_clone = session.clone()- session.clear()- await self.sessions.save(session)- # Run consolidation in background- await self._safe_consolidate_memory(session_clone, archive_all=True)+ if self._ov_session_context_enabled():+ committed = await self._commit_openviking_session(+ session,+ keep_recent_count=0,+ clear_local_session=True,+ )+ if not committed:+ return OutboundMessage(+ session_key=msg.session_key,+ content="🐈 Memory consolidation failed. Session history was kept.",+ metadata=msg.metadata,+ )+ else:+ session_clone = session.clone()+ session.clear()+ await self.sessions.save(session)+ # Run consolidation in background+ await self._safe_consolidate_memory(session_clone, archive_all=True)return OutboundMessage(session_key=msg.session_key,content="🐈 New session started. Memory consolidated.",@@ -590,7 +863,18 @@ class AgentLoop:content="🐈 Sorry, you are not authorized to use this command.",metadata=msg.metadata,)- if ov_tools_enable:+ if self._ov_session_context_enabled():+ remembered = await self._commit_openviking_session(+ session,+ keep_recent_count=self.config.agents.commit_keep_recent_count,+ )+ if not remembered:+ return OutboundMessage(+ session_key=msg.session_key,+ content="Failed to submit this conversation to memory storage.",+ metadata=msg.metadata,+ )+ elif ov_tools_enable:session_clone = session.clone()await self._consolidate_viking_memory(session_clone)return OutboundMessage(@@ -624,8 +908,12 @@ class AgentLoop:event_type=OutboundEventType.NO_REPLY,)+ await self._evaluate_previous_response_outcome(session, msg)+# Consolidate memory before processing if session is too large- if len(session.messages) > self.memory_window:+ if self._ov_session_context_enabled():+ await self._maybe_commit_openviking_before_turn(session, msg)+ elif len(session.messages) > self.memory_window:# Clone session for async consolidation, then immediately trim originalsession_clone = session.clone()keep_count = min(10, max(2, self.memory_window // 2))@@ -634,8 +922,6 @@ class AgentLoop:# Run consolidation in backgroundawait self._safe_consolidate_memory(session_clone, archive_all=False)- await self._evaluate_previous_response_outcome(session, msg)-if self.sandbox_manager:message_workspace = self.sandbox_manager.get_workspace_path(session_key)else:@@ -652,10 +938,11 @@ class AgentLoop:eval=self._eval,)- # Build initial messages (use get_history for LLM-formatted messages)+ # Build initial messages (use OpenViking session context when enabled)provider_name = self.config.get_provider_name(self.model) if self.config else None+ history = await self._build_prompt_history(session, provider_name=provider_name)messages = await message_context.build_messages(- history=session.get_history(provider_name=provider_name),+ history=history,current_message=msg.content,media=msg.media if msg.media else None,session_key=msg.session_key,@@ -714,6 +1001,11 @@ class AgentLoop:)session.metadata.setdefault("response_facts", {})[response_id] = response_completedawait self.sessions.save(session)+ if self._ov_session_context_enabled():+ await self._submit_openviking_session_and_clear_if_committed(+ session,+ commit_message_threshold=self.memory_window,+ )LangfuseClient.get_instance().update_generation_metadata(response_id, response_completed)@@ -879,8 +1171,9 @@ class AgentLoop:# Build messages with the announce contentprovider_name = self.config.get_provider_name(self.model) if self.config else None+ history = await self._build_prompt_history(session, provider_name=provider_name)messages = await self.context.build_messages(- history=session.get_history(provider_name=provider_name),+ history=history,current_message=msg.content,session_key=msg.session_key,ov_tools_enable=ov_tools_enable,@@ -1097,4 +1390,4 @@ Respond with ONLY valid JSON, no markdown fences.""")response = await self._process_message(msg)- return response.content if response else ""\ No newline at end of file+ return response.content if response else ""diff --git a/bot/vikingbot/config/schema.py b/bot/vikingbot/config/schema.pyindex 19e7db3e6..19f972931 100644--- a/bot/vikingbot/config/schema.py+++ b/bot/vikingbot/config/schema.py@@ -433,6 +433,10 @@ class AgentsConfig(BaseModel):model: str = "openai/doubao-seed-2-0-pro-260215"max_tool_iterations: int = 50memory_window: int = 50+ session_context_enabled: bool = False+ session_context_token_budget: int = 3000+ commit_token_threshold: int = 20000+ commit_keep_recent_count: int = 5gen_image_model: str = "openai/doubao-seedream-4-5-251128"provider: str = ""api_key: str = ""diff --git a/bot/vikingbot/heartbeat/service.py b/bot/vikingbot/heartbeat/service.pyindex 4222ef675..ed916273a 100644--- a/bot/vikingbot/heartbeat/service.py+++ b/bot/vikingbot/heartbeat/service.py@@ -175,8 +175,6 @@ class HeartbeatService:active_workspaces = 0for workspace_path, session_key_list in workspaces.items():- logger.debug(f"Heartbeat: checking workspace {workspace_path}...")-content = _read_heartbeat_file(workspace_path)# Skip if HEARTBEAT.md is empty or doesn't exist@@ -211,9 +209,6 @@ class HeartbeatService:except Exception as e:logger.exception(f"Heartbeat execution failed for {workspace_path}: {e}")- if active_workspaces == 0:- logger.debug("Heartbeat: no tasks in any workspace")-async def trigger_now(self, session_key: SessionKey | None = None) -> str | None:"""Manually trigger a heartbeat."""if self.on_heartbeat:diff --git a/bot/vikingbot/hooks/builtins/openviking_hooks.py b/bot/vikingbot/hooks/builtins/openviking_hooks.pyindex 18810b0ad..a44325aa4 100644--- a/bot/vikingbot/hooks/builtins/openviking_hooks.py+++ b/bot/vikingbot/hooks/builtins/openviking_hooks.py@@ -1,11 +1,21 @@import asyncioimport refrom collections import defaultdict+from datetime import datetimefrom typing import Anyfrom loguru import loggerfrom vikingbot.config.loader import load_config+from vikingbot.openviking_mount.session_state import (+ get_openviking_session_id,+ get_openviking_state,+ get_unsynced_messages,+ get_unsynced_messages_for_sender,+ parse_local_index,+ set_sender_synced_local_index,+)+from vikingbot.utils.helpers import cal_str_tokensfrom ...session import Sessionfrom ..base import Hook, HookContext@@ -40,15 +50,273 @@ class OpenVikingCompactHook(Hook):async def _get_client(self, workspace_id: str) -> VikingClient:return await get_global_client(workspace_id)+ async def _execute_session_context_commit(+ self,+ context: HookContext,+ session: Session,+ client: VikingClient,+ agents_config: Any,+ admin_user_id: str,+ *,+ force_commit: bool,+ keep_recent_count: int,+ commit_message_threshold: int | None,+ ) -> dict[str, Any]:+ state = get_openviking_state(session)+ session_id = get_openviking_session_id(+ session,+ default_session_id=context.session_key.safe_name(),+ )++ commit_token_threshold = int(getattr(agents_config, "commit_token_threshold", 6000) or 6000)+ pending_tokens = int(state.get("last_pending_tokens", 0) or 0)+ messages_to_sync = get_unsynced_messages(session)+ last_commit_local_index = parse_local_index(state.get("last_commit_local_index", -1))+ messages_since_commit = len(session.messages) - last_commit_local_index - 1+ reached_message_threshold = bool(+ commit_message_threshold is not None+ and commit_message_threshold > 0+ and messages_since_commit >= commit_message_threshold+ )++ admin_append_result = None+ admin_commit_result = None+ user_results = []+ pending_tokens_before_sync = pending_tokens++ unsynced_tokens = sum(+ cal_str_tokens(str(msg.get("content") or ""))+ for msg in messages_to_sync+ if msg.get("content") is not None+ )++ all_sender_ids = sorted(+ {+ str(msg.get("sender_id"))+ for msg in session.messages+ if msg.get("sender_id") and msg.get("sender_id") != admin_user_id+ }+ )+ unsynced_messages_by_sender = {}+ sender_latest_indexes: dict[str, int] = {}+ for sender_id in all_sender_ids:+ user_messages = get_unsynced_messages_for_sender(+ session,+ sender_id,+ admin_user_id=admin_user_id,+ )+ if user_messages:+ unsynced_messages_by_sender[sender_id] = user_messages+ sender_latest_indexes[sender_id] = max(+ index+ for index, msg in enumerate(session.messages)+ if msg.get("sender_id") == sender_id+ )++ should_commit = bool(+ force_commit+ or pending_tokens + unsynced_tokens >= commit_token_threshold+ or reached_message_threshold+ )+ sender_ids_to_sync = (+ all_sender_ids if should_commit else sorted(unsynced_messages_by_sender)+ )+ user_results_by_id: dict[str, dict[str, Any]] = {}++ if sender_ids_to_sync:+ semaphore = asyncio.Semaphore(5)++ async def sync_sender(user_id: str):+ user_messages = unsynced_messages_by_sender.get(user_id, [])+ async with semaphore:+ sender_session_id = f"{session_id}_{user_id}"+ append_result = None+ if user_messages:+ append_result = await client.append_messages(+ session_id=sender_session_id,+ messages=user_messages,+ default_user_role_id=user_id,+ session_user_id=user_id,+ )+ return {+ "session_id": sender_session_id,+ "user_id": user_id,+ "append": append_result,+ }++ user_results = await asyncio.gather(+ *(sync_sender(user_id) for user_id in sender_ids_to_sync),+ return_exceptions=True,+ )+ for result in user_results:+ if isinstance(result, dict):+ user_id = result["user_id"]+ user_results_by_id[user_id] = result+ if result.get("append") is not None and user_id in sender_latest_indexes:+ set_sender_synced_local_index(+ session, user_id, sender_latest_indexes[user_id]+ )++ fanout_errors = [result for result in user_results if isinstance(result, Exception)]+ if fanout_errors:+ error_message = "; ".join(str(error) for error in fanout_errors)+ state["last_pending_tokens"] = pending_tokens_before_sync+ state["last_commit_performed"] = False+ state["last_sync_status"] = "error"+ state["last_sync_error"] = error_message+ return {+ "success": False,+ "session_id": session_id,+ "admin_result": {+ "append": admin_append_result,+ "commit": admin_commit_result,+ "committed": False,+ },+ "user_results": user_results,+ "users_count": len(sender_ids_to_sync),+ "pending_tokens": pending_tokens_before_sync,+ "error": error_message,+ }++ if messages_to_sync:+ admin_append_result = await client.append_messages(+ session_id=session_id,+ messages=messages_to_sync,+ default_user_role_id=admin_user_id,+ session_user_id=admin_user_id,+ )+ state["last_synced_local_index"] = len(session.messages) - 1+ admin_session_state = await client.get_session(session_id, user_id=admin_user_id)+ pending_tokens = int(admin_session_state.get("pending_tokens", 0) or 0)+ elif force_commit:+ admin_session_state = await client.get_session(session_id, user_id=admin_user_id)+ pending_tokens = int(admin_session_state.get("pending_tokens", 0) or 0)++ should_commit = (+ force_commit or pending_tokens >= commit_token_threshold or reached_message_threshold+ )+ if should_commit:+ sender_ids_to_commit = all_sender_ids+ for user_id in sender_ids_to_commit:+ user_results_by_id.setdefault(+ user_id,+ {+ "session_id": f"{session_id}_{user_id}",+ "user_id": user_id,+ "append": None,+ },+ )++ if sender_ids_to_commit:+ semaphore = asyncio.Semaphore(5)++ async def commit_sender(user_id: str):+ async with semaphore:+ sender_session_id = f"{session_id}_{user_id}"+ logger.info(+ f"[HOOK] Committed session {sender_session_id} for user {user_id}"+ )+ return await client.commit_session(+ session_id=sender_session_id,+ keep_recent_count=keep_recent_count,+ user_id=user_id,+ )++ commit_results = await asyncio.gather(+ *(commit_sender(user_id) for user_id in sender_ids_to_commit),+ return_exceptions=True,+ )+ for user_id, commit_result in zip(+ sender_ids_to_commit, commit_results, strict=True+ ):+ user_results_by_id[user_id]["commit"] = commit_result+ fanout_errors = [+ result for result in commit_results if isinstance(result, Exception)+ ]+ if fanout_errors:+ error_message = "; ".join(str(error) for error in fanout_errors)+ state["last_pending_tokens"] = pending_tokens+ state["last_commit_performed"] = False+ state["last_sync_status"] = "error"+ state["last_sync_error"] = error_message+ return {+ "success": False,+ "session_id": session_id,+ "admin_result": {+ "append": admin_append_result,+ "commit": admin_commit_result,+ "committed": False,+ },+ "user_results": list(user_results_by_id.values()),+ "users_count": len(user_results_by_id),+ "pending_tokens": pending_tokens,+ "error": error_message,+ }++ admin_commit_result = await client.commit_session(+ session_id=session_id,+ keep_recent_count=keep_recent_count,+ user_id=admin_user_id,+ )+ logger.info(f"[HOOK] Committed session {session_id} for user {admin_user_id}")+ admin_session_state = await client.get_session(session_id, user_id=admin_user_id)+ pending_tokens = int(admin_session_state.get("pending_tokens", 0) or 0)++ if should_commit:+ state["last_commit_at"] = datetime.now().isoformat()+ state["last_commit_local_index"] = len(session.messages) - 1+ state["last_pending_tokens"] = pending_tokens+ state["last_commit_performed"] = should_commit+ state["last_sync_status"] = "success"+ state.pop("last_sync_error", None)++ return {+ "success": True,+ "session_id": session_id,+ "admin_result": {+ "append": admin_append_result,+ "commit": admin_commit_result,+ "committed": should_commit,+ },+ "user_results": list(user_results_by_id.values()),+ "users_count": len(user_results_by_id),+ "pending_tokens": pending_tokens,+ }+async def execute(self, context: HookContext, **kwargs) -> Any:vikingbot_session: Session = kwargs.get("session", {})session_id = context.session_key.safe_name()config = load_config()- admin_user_id = config.ov_server.admin_user_id+ ov_config = config.ov_server+ agents_config = config.agents+ admin_user_id = ov_config.admin_user_id+ force_commit = bool(kwargs.get("force_commit", False))+ keep_recent_count = int(+ kwargs.get(+ "keep_recent_count",+ getattr(agents_config, "commit_keep_recent_count", 10),+ )+ or 0+ )+ commit_message_threshold = kwargs.get("commit_message_threshold")+ if commit_message_threshold is not None:+ commit_message_threshold = int(commit_message_threshold)try:client = await self._get_client(context.workspace_id)+ if getattr(agents_config, "session_context_enabled", False):+ return await self._execute_session_context_commit(+ context,+ vikingbot_session,+ client,+ agents_config,+ admin_user_id,+ force_commit=force_commit,+ keep_recent_count=keep_recent_count,+ commit_message_threshold=commit_message_threshold,+ )+if not client.should_sender_fanout():single_result = await client.commit(session_id, vikingbot_session.messages, None)return {@@ -92,6 +360,11 @@ class OpenVikingCompactHook(Hook):"users_count": len(messages_by_sender),}except Exception as e:+ state = None+ if hasattr(vikingbot_session, "metadata"):+ state = get_openviking_state(vikingbot_session)+ state["last_sync_status"] = "error"+ state["last_sync_error"] = str(e)logger.exception(f"Failed to add message to OpenViking: {e}")return {"success": False, "error": str(e)}diff --git a/bot/vikingbot/hooks/manager.py b/bot/vikingbot/hooks/manager.pyindex a78b918b3..e80aa2177 100644--- a/bot/vikingbot/hooks/manager.py+++ b/bot/vikingbot/hooks/manager.py@@ -1,7 +1,7 @@import asyncioimport importlibfrom collections import defaultdict-from typing import List, Any, Dict, Type+from typing import Any, Dict, List, Typefrom loguru import logger@@ -47,9 +47,6 @@ class HookManager:async_hooks = [hook for hook in self._hooks[context.event_type] if not hook.is_sync]sync_hooks = [hook for hook in self._hooks[context.event_type] if hook.is_sync]if async_hooks:- logger.debug(- f"Executing {len(async_hooks)} async hooks for event '{context.event_type}'"- )async_results = await asyncio.gather(*[hook.execute(context, **kwargs) for hook in async_hooks], return_exceptions=True)diff --git a/bot/vikingbot/openviking_mount/ov_server.py b/bot/vikingbot/openviking_mount/ov_server.pyindex 6aa6af21a..051ffbd55 100644--- a/bot/vikingbot/openviking_mount/ov_server.py+++ b/bot/vikingbot/openviking_mount/ov_server.py@@ -1,6 +1,5 @@import asyncioimport hashlib-import timefrom typing import Any, Dict, List, Optionalfrom loguru import logger@@ -24,6 +23,8 @@ class VikingClient:raise ValueError(f"Invalid ov_server.api_key_type: {self.api_key_type}")self._apikey_manager = None+ self.admin_user_client = None+ self._user_clients = {}self._namespace_policy = {"isolate_user_scope_by_agent": False,"isolate_agent_scope_by_user": False,@@ -484,111 +485,187 @@ class VikingClient:if should_close:await client.close()- async def commit(self, session_id: str, messages: list[dict[str, Any]], user_id: str = None):- """提交会话"""- import re- import uuid+ def _session_client(self, user_id: Optional[str] = None):+ if user_id and user_id == self.admin_user_id and self.admin_user_client:+ return self.admin_user_client+ return self.admin_user_client or self.client- from openviking.message.part import TextPart, ToolPart+ async def _session_client_for_user(self, user_id: Optional[str] = None):+ if not user_id or self.mode == "local" or self._is_user_key_mode():+ return self._session_client(user_id)+ if user_id == self.admin_user_id and self.admin_user_client:+ return self.admin_user_client- effective_user_id = self._effective_user_id(user_id)+ user_exists = await self._check_user_exists(user_id)+ if not user_exists:+ await self._initialize_user(user_id)++ api_key = await self._get_or_create_user_apikey(user_id)+ if not api_key:+ return self._session_client(user_id)++ client = self._user_clients.get(user_id)+ if client is None:+ client = ov.AsyncHTTPClient(+ url=self.openviking_config.server_url,+ api_key=api_key,+ agent_id=self.agent_id,+ account=self.account_id,+ user=user_id,+ )+ await client.initialize()+ self._user_clients[user_id] = client+ return client- client = self.client- start = time.time()- if self._is_root_key_mode():- user_exists = await self._check_user_exists(effective_user_id)- if not user_exists:- success = await self._initialize_user(effective_user_id)- if not success:- return {"error": "Failed to initialize user"}-- if (- effective_user_id- and effective_user_id != self.admin_user_id- and self._apikey_manager- ):- user_api_key = await self._get_or_create_user_apikey(effective_user_id)- if user_api_key:- client = ov.AsyncHTTPClient(- url=self.openviking_config.server_url,- api_key=user_api_key,- agent_id=self.agent_id,- )- await client.initialize()-- create_res = await client.create_session()- session_id = create_res["session_id"]- session = client.session(session_id)+ def _assistant_role_id(self) -> Optional[str]:+ if self.agent_id:+ return self.agent_id+ if self.admin_user_id:+ return self.admin_user_id+ return None++ def _normalize_session_messages(+ self,+ messages: list[dict[str, Any]],+ default_user_role_id: Optional[str] = None,+ ) -> list[dict[str, Any]]:+ normalized: list[dict[str, Any]] = []+ assistant_role_id = self._assistant_role_id()for message in messages:- role = message.get("role")- content = message.get("content")- tools_used = message.get("tools_used") or []-- parts: list[Any] = []-- if content:- parts.append(TextPart(text=content))-- for tool_info in tools_used:- tool_name = tool_info.get("tool_name", "")- if not tool_name:- continue-- tool_id = f"{tool_name}_{uuid.uuid4().hex[:8]}"- tool_input = None- try:- import json-- args_str = tool_info.get("args", "{}")- tool_input = json.loads(args_str) if args_str else {}- except Exception:- tool_input = {"raw_args": tool_info.get("args", "")}-- result_str = str(tool_info.get("result", ""))-- skill_uri = ""- if tool_name == "read_file" and result_str:- match = re.search(r"^---\s*\nname:\s*(.+?)\s*\n", result_str, re.MULTILINE)- if match:- skill_name = match.group(1).strip()- skill_uri = f"viking://agent/skills/{skill_name}"-- execute_success = tool_info.get("execute_success", True)- tool_status = "completed" if execute_success else "error"- parts.append(- ToolPart(- tool_id=tool_id,- tool_name=tool_name,- tool_uri=f"viking://session/{session_id}/tools/{tool_id}",- tool_input=tool_input,- tool_output=result_str[:2000],- tool_status=tool_status,- skill_uri=skill_uri,- duration_ms=float(tool_info.get("duration", 0.0)),- prompt_tokens=tool_info.get("input_token"),- completion_tokens=tool_info.get("output_token"),- )- )+ role = str(message.get("role") or "").strip().lower()+ if role not in {"user", "assistant", "system", "tool"}:+ continue- if not parts:+ content = self._session_message_content(message)+ if not content:continue- # 获取消息的时间戳,如果没有则使用当前时间- created_at = message.get("timestamp")- await session.add_message(role=role, parts=parts, created_at=created_at)- result = await session.commit_async()- if client is not self.client:- await client.close()- logger.info(f"time spent: {time.time() - start}")+ ov_role = "user" if role == "user" else "assistant"+ payload = {+ "role": ov_role,+ "content": content,+ "created_at": message.get("created_at") or message.get("timestamp"),+ }++ role_id = message.get("role_id")+ if not role_id and ov_role == "user":+ role_id = message.get("sender_id") or default_user_role_id+ elif not role_id and ov_role == "assistant":+ role_id = assistant_role_id++ if role_id:+ payload["role_id"] = role_id++ normalized.append(payload)++ return normalized++ def _session_message_content(self, message: dict[str, Any]) -> str:+ content = message.get("content")+ if isinstance(content, str) and content.strip():+ return content.strip()+ return ""++ async def ensure_session(+ self, session_id: str, user_id: Optional[str] = None+ ) -> Dict[str, Any]:+ client = await self._session_client_for_user(user_id)+ if await client.session_exists(session_id):+ return await client.get_session(session_id)+ return await client.create_session(session_id=session_id)++ async def get_session(self, session_id: str, user_id: Optional[str] = None) -> Dict[str, Any]:+ await self.ensure_session(session_id, user_id=user_id)+ client = await self._session_client_for_user(user_id)+ return await client.get_session(session_id)++ async def get_session_context(+ self, session_id: str, token_budget: int, user_id: Optional[str] = None+ ) -> Dict[str, Any]:+ await self.ensure_session(session_id, user_id=user_id)+ client = await self._session_client_for_user(user_id)+ return await client.get_session_context(+ session_id,+ token_budget=token_budget,+ )++ async def append_messages(+ self,+ session_id: str,+ messages: list[dict[str, Any]],+ default_user_role_id: Optional[str] = None,+ session_user_id: Optional[str] = None,+ ) -> Dict[str, Any]:+ await self.ensure_session(session_id, user_id=session_user_id)+ batch = self._normalize_session_messages(+ messages,+ default_user_role_id=default_user_role_id,+ )+ if not batch:+ return {"session_id": session_id, "added": 0, "message_count": 0}+ client = await self._session_client_for_user(session_user_id)+ total_added = 0+ message_count = 0+ for start in range(0, len(batch), 100):+ result = await client.batch_add_messages(+ session_id=session_id,+ messages=batch[start : start + 100],+ )+ total_added += int(result.get("added", 0) or 0)+ message_count = int(result.get("message_count", message_count) or 0)+ return {"session_id": session_id, "added": total_added, "message_count": message_count}++ async def commit_session(+ self,+ session_id: str,+ keep_recent_count: int = 0,+ user_id: Optional[str] = None,+ ) -> Dict[str, Any]:+ await self.ensure_session(session_id, user_id=user_id)+ client = await self._session_client_for_user(user_id)+ return await client.commit_session(+ session_id,+ keep_recent_count=keep_recent_count,+ )++ async def commit(+ self,+ session_id: str,+ messages: list[dict[str, Any]],+ user_id: str = None,+ keep_recent_count: int = 0,+ ):+ """Append messages to a stable session and commit it."""+ appended = await self.append_messages(+ session_id,+ messages,+ default_user_role_id=user_id or self.admin_user_id,+ session_user_id=user_id,+ )+ commit_result = await self.commit_session(+ session_id,+ keep_recent_count=keep_recent_count,+ user_id=user_id,+ )logger.debug(- f"Message add ed to OpenViking session {session_id}, api_key_type={self.api_key_type}, user: {effective_user_id}"+ f"Committed OpenViking session {session_id}, "+ f"api_key_type={self.api_key_type}, appended={appended.get('added', 0)}")- return {"success": result["status"]}+ return {+ "success": True,+ "session_id": session_id,+ "append": appended,+ "commit": commit_result,+ }async def close(self):"""关闭客户端"""await self.client.close()+ if self.admin_user_client:+ await self.admin_user_client.close()+ for client in self._user_clients.values():+ await client.close()async def main_test():diff --git a/bot/vikingbot/openviking_mount/session_state.py b/bot/vikingbot/openviking_mount/session_state.pynew file mode 100644index 000000000..be8e0ec4a--- /dev/null+++ b/bot/vikingbot/openviking_mount/session_state.py@@ -0,0 +1,105 @@+from __future__ import annotations++import uuid+from typing import Any++from vikingbot.session.manager import Session+++def get_openviking_state(session: Session) -> dict[str, Any]:+ state = session.metadata.get("openviking")+ if not isinstance(state, dict):+ state = {}+ session.metadata["openviking"] = state+ return state+++def parse_local_index(value: Any, default: int = -1) -> int:+ try:+ index = int(value)+ except (TypeError, ValueError):+ index = default+ return max(index, -1)+++def get_openviking_session_id(+ session: Session,+ *,+ rotate: bool = False,+ default_session_id: str | None = None,+) -> str:+ state = get_openviking_state(session)+ current_session_id = str(state.get("session_id") or "").strip()+ if current_session_id and not rotate:+ return current_session_id++ if default_session_id:+ base_session_id = default_session_id+ else:+ base_session_id = session.key.safe_name()+ session_id = f"{base_session_id}-{uuid.uuid4().hex[:8]}" if rotate else base_session_id+ state["session_id"] = session_id+ return session_id+++def reset_openviking_state(session: Session, *, rotate_session_id: bool = False) -> None:+ session_id = get_openviking_session_id(session, rotate=rotate_session_id)+ session.metadata["openviking"] = {+ "session_id": session_id,+ "last_synced_local_index": -1,+ "last_sender_synced_local_indexes": {},+ "last_pending_tokens": 0,+ "last_commit_local_index": -1,+ "last_sync_status": "reset",+ }+++def get_unsynced_messages(+ session: Session, *, cursor_key: str = "last_synced_local_index"+) -> list[dict[str, Any]]:+ state = get_openviking_state(session)+ last_synced_local_index = parse_local_index(state.get(cursor_key, -1))+ if last_synced_local_index >= len(session.messages):+ return []+ start = last_synced_local_index + 1+ return list(session.messages[start:]) if start < len(session.messages) else []+++def get_sender_synced_local_indexes(session: Session) -> dict[str, int]:+ state = get_openviking_state(session)+ raw_indexes = state.get("last_sender_synced_local_indexes")+ if not isinstance(raw_indexes, dict):+ raw_indexes = {}+ state["last_sender_synced_local_indexes"] = raw_indexes+ return {str(sender_id): parse_local_index(index) for sender_id, index in raw_indexes.items()}+++def set_sender_synced_local_index(session: Session, sender_id: str, index: int) -> None:+ state = get_openviking_state(session)+ raw_indexes = state.get("last_sender_synced_local_indexes")+ if not isinstance(raw_indexes, dict):+ raw_indexes = {}+ state["last_sender_synced_local_indexes"] = raw_indexes+ raw_indexes[str(sender_id)] = parse_local_index(index)+++def get_unsynced_messages_for_sender(+ session: Session,+ sender_id: str,+ *,+ admin_user_id: str | None = None,+) -> list[dict[str, Any]]:+ sender_indexes = get_sender_synced_local_indexes(session)+ state = get_openviking_state(session)+ last_synced_local_index = sender_indexes.get(+ str(sender_id),+ parse_local_index(state.get("last_synced_local_index", -1)),+ )+ if last_synced_local_index >= len(session.messages):+ return []+ start = last_synced_local_index + 1+ return [+ message+ for message in session.messages[start:]+ if message.get("sender_id") == sender_id and sender_id != admin_user_id+ ]diff --git a/bot/vikingbot/session/manager.py b/bot/vikingbot/session/manager.pyindex bd3bb41b1..9e401f038 100644--- a/bot/vikingbot/session/manager.py+++ b/bot/vikingbot/session/manager.py@@ -303,7 +303,9 @@ class SessionManager:continuecurrent = merged[key]- if isinstance(current, dict) and isinstance(value, dict):+ if key == "openviking":+ merged[key] = value+ elif isinstance(current, dict) and isinstance(value, dict):merged[key] = cls._merge_metadata(current, value)elif isinstance(current, list) and isinstance(value, list):merged[key] = current + [item for item in value if item not in current]diff --git a/openviking/async_client.py b/openviking/async_client.pyindex 92cd1e17e..debda7841 100644--- a/openviking/async_client.py+++ b/openviking/async_client.py@@ -200,12 +200,34 @@ class AsyncOpenViking:telemetry=telemetry,)+ async def batch_add_messages(+ self,+ session_id: str,+ messages: list[dict],+ telemetry: TelemetryRequest = False,+ ) -> Dict[str, Any]:+ """Add multiple messages to a session in a single request."""+ await self._ensure_initialized()+ return await self._client.batch_add_messages(+ session_id=session_id,+ messages=messages,+ telemetry=telemetry,+ )+async def commit_session(- self, session_id: str, telemetry: TelemetryRequest = False+ self,+ session_id: str,+ telemetry: TelemetryRequest = False,+ *,+ keep_recent_count: int = 0,) -> Dict[str, Any]:"""Commit a session (archive and extract memories)."""await self._ensure_initialized()- return await self._client.commit_session(session_id, telemetry=telemetry)+ return await self._client.commit_session(+ session_id,+ telemetry=telemetry,+ keep_recent_count=keep_recent_count,+ )async def get_task(self, task_id: str) -> Optional[Dict[str, Any]]:"""Query background task status."""diff --git a/openviking/client/local.py b/openviking/client/local.pyindex 8dbce07d4..24eda0fd7 100644--- a/openviking/client/local.py+++ b/openviking/client/local.py@@ -463,13 +463,21 @@ class LocalClient(BaseClient):await self._service.sessions.delete(session_id, self._ctx)async def commit_session(- self, session_id: str, telemetry: TelemetryRequest = False+ self,+ session_id: str,+ telemetry: TelemetryRequest = False,+ *,+ keep_recent_count: int = 0,) -> Dict[str, Any]:"""Commit a session (archive and extract memories)."""execution = await run_with_telemetry(operation="session.commit",telemetry=telemetry,- fn=lambda: self._service.sessions.commit(session_id, self._ctx),+ fn=lambda: self._service.sessions.commit(+ session_id,+ self._ctx,+ keep_recent_count=keep_recent_count,+ ),)return attach_telemetry_payload(execution.result,diff --git a/openviking/client/session.py b/openviking/client/session.pyindex f2e904b4f..181e59c57 100644--- a/openviking/client/session.py+++ b/openviking/client/session.py@@ -92,22 +92,36 @@ class Session:messages=messages,)- async def commit(self, telemetry: TelemetryRequest = False) -> Dict[str, Any]:+ async def commit(+ self,+ telemetry: TelemetryRequest = False,+ *,+ keep_recent_count: int = 0,+ ) -> Dict[str, Any]:"""Commit the session (archive messages and extract memories).Returns:Commit result"""- return await self._client.commit_session(self.session_id, telemetry=telemetry)+ return await self._client.commit_session(+ self.session_id,+ telemetry=telemetry,+ keep_recent_count=keep_recent_count,+ )- async def commit_async(self, telemetry: TelemetryRequest = False) -> Dict[str, Any]:+ async def commit_async(+ self,+ telemetry: TelemetryRequest = False,+ *,+ keep_recent_count: int = 0,+ ) -> Dict[str, Any]:"""Commit the session asynchronously (archive messages and extract memories).Used in viking bot for committing.Returns:Commit result"""- return await self.commit(telemetry)+ return await self.commit(telemetry=telemetry, keep_recent_count=keep_recent_count)async def delete(self) -> None:"""Delete the session."""diff --git a/openviking/sync_client.py b/openviking/sync_client.pyindex d6bd4ed2c..e00f66df7 100644--- a/openviking/sync_client.py+++ b/openviking/sync_client.py@@ -106,11 +106,36 @@ class SyncOpenViking:))+ def batch_add_messages(+ self,+ session_id: str,+ messages: list[dict],+ telemetry: TelemetryRequest = False,+ ) -> Dict[str, Any]:+ """Add multiple messages to a session in a single request."""+ return run_async(+ self._async_client.batch_add_messages(+ session_id,+ messages,+ telemetry,+ )+ )+def commit_session(- self, session_id: str, telemetry: TelemetryRequest = False+ self,+ session_id: str,+ telemetry: TelemetryRequest = False,+ *,+ keep_recent_count: int = 0,) -> Dict[str, Any]:"""Commit a session (archive and extract memories)."""- return run_async(self._async_client.commit_session(session_id, telemetry=telemetry))+ return run_async(+ self._async_client.commit_session(+ session_id,+ telemetry=telemetry,+ keep_recent_count=keep_recent_count,+ )+ )def get_task(self, task_id: str) -> Optional[Dict[str, Any]]:"""Query background task status."""diff --git a/openviking_cli/client/base.py b/openviking_cli/client/base.pyindex 9d47dc7e1..08cde9425 100644--- a/openviking_cli/client/base.py+++ b/openviking_cli/client/base.py@@ -264,9 +264,19 @@ class BaseClient(ABC):@abstractmethodasync def commit_session(- self, session_id: str, telemetry: TelemetryRequest = False+ self,+ session_id: str,+ telemetry: TelemetryRequest = False,+ *,+ keep_recent_count: int = 0,) -> Dict[str, Any]:- """Commit a session (archive and extract memories)."""+ """Commit a session (archive and extract memories).++ Args:+ 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.+ """...@abstractmethoddiff --git a/openviking_cli/client/http.py b/openviking_cli/client/http.pyindex 033f792ae..ede56065a 100644--- a/openviking_cli/client/http.py+++ b/openviking_cli/client/http.py@@ -876,13 +876,20 @@ class AsyncHTTPClient(BaseClient):return self._handle_response(response)async def commit_session(- self, session_id: str, telemetry: TelemetryRequest = False+ self,+ session_id: str,+ telemetry: TelemetryRequest = False,+ *,+ keep_recent_count: int = 0,) -> Dict[str, Any]:"""Commit a session (archive and extract memories)."""telemetry = self._validate_telemetry(telemetry)response = await self._http.post(f"/api/v1/sessions/{session_id}/commit",- json={"telemetry": telemetry},+ json={+ "keep_recent_count": keep_recent_count,+ "telemetry": telemetry,+ },)response_data = self._handle_response_data(response)return self._attach_telemetry(response_data.get("result"), response_data)diff --git a/openviking_cli/client/sync_http.py b/openviking_cli/client/sync_http.pyindex a586321c8..f482df8bb 100644--- a/openviking_cli/client/sync_http.py+++ b/openviking_cli/client/sync_http.py@@ -194,10 +194,20 @@ class SyncHTTPClient:)def commit_session(- self, session_id: str, telemetry: TelemetryRequest = False+ self,+ session_id: str,+ telemetry: TelemetryRequest = False,+ *,+ keep_recent_count: int = 0,) -> Dict[str, Any]:"""Commit a session (archive and extract memories)."""- return run_async(self._async_client.commit_session(session_id, telemetry=telemetry))+ return run_async(+ self._async_client.commit_session(+ session_id,+ telemetry=telemetry,+ keep_recent_count=keep_recent_count,+ )+ )# ============= Resource =============diff --git a/tests/server/test_http_client_sdk.py b/tests/server/test_http_client_sdk.pyindex 0d97e1690..99cbd192a 100644--- a/tests/server/test_http_client_sdk.py+++ b/tests/server/test_http_client_sdk.py@@ -202,6 +202,90 @@ async def test_sdk_session_lifecycle(http_client):assert isinstance(sessions, list)+async def test_sdk_batch_add_messages_and_commit_keep_recent_count(http_client):+ client, _ = http_client++ session_info = await client.create_session()+ session_id = session_info["session_id"]++ batch_result = await client.batch_add_messages(+ session_id,+ [+ {+ "role": "user",+ "role_id": "sdk-user-1",+ "created_at": "2026-05-01T12:00:00Z",+ "parts": [{"type": "text", "text": "Batch hello"}],+ },+ {+ "role": "assistant",+ "role_id": "sdk-bot-1",+ "created_at": "2026-05-01T12:00:05Z",+ "parts": [+ {"type": "text", "text": "Batch answer"},+ {+ "type": "context",+ "uri": "viking://resources/sdk-doc",+ "context_type": "resource",+ "abstract": "SDK doc abstract",+ },+ ],+ },+ {+ "role": "user",+ "content": "Keep me live",+ },+ ],+ )+ assert batch_result["added"] == 3++ pre_commit = await client.get_session_context(session_id)+ assert [m["role"] for m in pre_commit["messages"]] == ["user", "assistant", "user"]+ assert pre_commit["messages"][0]["role_id"] == "sdk-user-1"+ assert pre_commit["messages"][0]["created_at"] == "2026-05-01T12:00:00Z"+ assert pre_commit["messages"][1]["parts"][1]["type"] == "context"+ assert pre_commit["messages"][1]["parts"][1]["abstract"] == "SDK doc abstract"++ commit_result = await client.commit_session(session_id, keep_recent_count=1)+ task_id = commit_result["task_id"]++ for _ in range(100):+ task = await client.get_task(task_id)+ if task and task["status"] in ("completed", "failed"):+ break+ await asyncio.sleep(0.1)++ post_commit = await client.get_session_context(session_id)+ assert post_commit["latest_archive_overview"]+ assert [m["role"] for m in post_commit["messages"]] == ["user"]+ assert post_commit["messages"][0]["parts"][0]["text"] == "Keep me live"+++async def test_sdk_commit_session_keeps_telemetry_as_second_positional_argument():+ calls = []++ class _FakeHTTP:+ async def post(self, path, json):+ calls.append((path, json))+ return httpx.Response(+ 200,+ json={"status": "success", "result": {"task_id": "task-1"}},+ )++ client = AsyncHTTPClient(url="http://127.0.0.1:1933")+ client._http = _FakeHTTP()++ result = await client.commit_session("s1", True)++ assert result == {"task_id": "task-1"}+ assert calls == [+ (+ "/api/v1/sessions/s1/commit",+ {"keep_recent_count": 0, "telemetry": True},+ )+ ]++async def test_sdk_get_session_archive(http_client):client, _ = http_clientdiff --git a/tests/session/test_session_commit.py b/tests/session/test_session_commit.pyindex 31eb4ded8..1ea14ae0b 100644--- a/tests/session/test_session_commit.py+++ b/tests/session/test_session_commit.py@@ -10,6 +10,7 @@ from unittest.mock import AsyncMock, MagicMockimport pytestfrom openviking import AsyncOpenViking+from openviking.client.session import Session as ClientSessionfrom openviking.message import TextPartfrom openviking.service.task_tracker import get_task_trackerfrom openviking.session import Session@@ -154,6 +155,90 @@ class TestCommit:assert result2.get("status") == "accepted"assert result2.get("task_id") is not None+ async def test_commit_keep_recent_count_retains_live_tail_and_resets_pending_tokens(+ self, client: AsyncOpenViking+ ):+ session = client.session(session_id="commit_keep_recent_count_test")++ session.add_message("user", [TextPart("Round 1 user")])+ session.add_message("assistant", [TextPart("Round 1 assistant")])+ session.add_message("user", [TextPart("Round 2 user")])+ session.add_message("assistant", [TextPart("Round 2 assistant")])++ result = await session.commit_async(keep_recent_count=2)+ task_result = await _wait_for_task(result["task_id"])++ assert task_result["status"] == "completed"+ assert len(session.messages) == 2+ assert [message.parts[0].text for message in session.messages] == [+ "Round 2 user",+ "Round 2 assistant",+ ]++ session_info = await client.get_session(session.session_id)+ assert session_info["pending_tokens"] == 0++ context = await session.get_session_context()+ assert context["latest_archive_overview"]+ assert [message["parts"][0]["text"] for message in context["messages"]] == [+ "Round 2 user",+ "Round 2 assistant",+ ]++ async def test_session_commit_keeps_telemetry_as_first_positional_argument(self):+ calls = []++ class _FakeClient:+ async def commit_session(self, session_id, telemetry=False, *, keep_recent_count=0):+ calls.append(+ {+ "session_id": session_id,+ "telemetry": telemetry,+ "keep_recent_count": keep_recent_count,+ }+ )+ return {"task_id": "task-1"}++ session = ClientSession(_FakeClient(), "s1", "user-1")++ result = await session.commit(True)++ assert result == {"task_id": "task-1"}+ assert calls == [+ {+ "session_id": "s1",+ "telemetry": True,+ "keep_recent_count": 0,+ }+ ]++ async def test_session_commit_async_keeps_telemetry_as_first_positional_argument(self):+ calls = []++ class _FakeClient:+ async def commit_session(self, session_id, telemetry=False, *, keep_recent_count=0):+ calls.append(+ {+ "session_id": session_id,+ "telemetry": telemetry,+ "keep_recent_count": keep_recent_count,+ }+ )+ return {"task_id": "task-1"}++ session = ClientSession(_FakeClient(), "s1", "user-1")++ result = await session.commit_async(True)++ assert result == {"task_id": "task-1"}+ assert calls == [+ {+ "session_id": "s1",+ "telemetry": True,+ "keep_recent_count": 0,+ }+ ]+async def test_commit_uses_latest_archive_overview_for_summary_and_extraction(self, client: AsyncOpenViking):diff --git a/tests/session/test_session_messages.py b/tests/session/test_session_messages.pyindex 8efcd78fc..6cd8000a9 100644--- a/tests/session/test_session_messages.py+++ b/tests/session/test_session_messages.py@@ -3,6 +3,9 @@"""Message management tests"""+import pytest++from openviking import AsyncOpenVikingfrom openviking.message import ContextPart, TextPart, ToolPartfrom openviking.session import Session@@ -71,6 +74,96 @@ class TestAddMessage:assert len(session.messages) == initial_count + 2+ async def test_batch_add_messages_preserves_role_id_created_at_and_parts(+ self, client: AsyncOpenViking+ ):+ session_id = "batch_message_preservation_test"+ await client.create_session(session_id=session_id)++ result = await client.batch_add_messages(+ session_id,+ [+ {+ "role": "user",+ "role_id": "user-123",+ "created_at": "2026-05-01T12:00:00Z",+ "parts": [+ {"type": "text", "text": "Hello batch"},+ {+ "type": "context",+ "uri": "viking://resources/test-doc",+ "context_type": "resource",+ "abstract": "Test document",+ },+ ],+ },+ {+ "role": "assistant",+ "role_id": "assistant-123",+ "created_at": "2026-05-01T12:00:05Z",+ "parts": [+ {"type": "text", "text": "Executing tool"},+ {+ "type": "tool",+ "tool_id": "tool_123",+ "tool_name": "search_tool",+ "tool_uri": f"viking://session/test/{session_id}/tools/tool_123",+ "skill_uri": "viking://agent/skills/search",+ "tool_status": "completed",+ "tool_output": "Found a result",+ },+ ],+ },+ ],+ )++ assert result["added"] == 2++ context = await client.get_session_context(session_id)+ assert [message["role"] for message in context["messages"]] == ["user", "assistant"]+ assert context["messages"][0]["role_id"] == "user-123"+ assert context["messages"][0]["created_at"] == "2026-05-01T12:00:00Z"+ assert context["messages"][0]["parts"][1] == {+ "type": "context",+ "uri": "viking://resources/test-doc",+ "context_type": "resource",+ "abstract": "Test document",+ }+ assert context["messages"][1]["role_id"] == "assistant-123"+ assert context["messages"][1]["created_at"] == "2026-05-01T12:00:05Z"+ assert context["messages"][1]["parts"][1]["type"] == "tool"+ assert context["messages"][1]["parts"][1]["tool_status"] == "completed"+ assert context["messages"][1]["parts"][1]["tool_output"] == "Found a result"++ async def test_batch_add_messages_is_atomic_when_later_message_is_invalid(+ self, client: AsyncOpenViking+ ):+ session_id = "batch_message_atomicity_test"+ await client.create_session(session_id=session_id)++ with pytest.raises(ValueError, match="Either content or parts must be provided"):+ await client.batch_add_messages(+ session_id,+ [+ {"role": "user", "content": "first valid message"},+ {"role": "assistant"},+ ],+ )++ context = await client.get_session_context(session_id)+ assert context["messages"] == []++ result = await client.batch_add_messages(+ session_id,+ [{"role": "user", "content": "first valid message"}],+ )++ assert result["added"] == 1+ context = await client.get_session_context(session_id)+ assert [message["parts"][0]["text"] for message in context["messages"]] == [+ "first valid message"+ ]+class TestUpdateToolPart:"""Test update_tool_part"""