Skip to content

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

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.md
new file mode 100644
index 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.py
index 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 datetime
from pathlib import Path
import pytest
+from vikingbot.agent import loop as loop_module
from vikingbot.agent.loop import AgentLoop
from vikingbot.bus.events import InboundMessage, OutboundEventType
from 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.asyncio
async 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_tu
assert 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.asyncio
async 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_ou
assert "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.asyncio
async 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.py
index 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 HookContext
from vikingbot.hooks.builtins.openviking_hooks import OpenVikingCompactHook
from vikingbot.openviking_mount import ov_server as ov_server_module
from vikingbot.openviking_mount.ov_server import VikingClient
+from vikingbot.openviking_mount.session_state import reset_openviking_state
+from vikingbot.session.manager import SessionManager
class _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 True
assert 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.py
index d771eb349..3668083a4 100644
--- a/bot/vikingbot/agent/loop.py
+++ b/bot/vikingbot/agent/loop.py
@@ -28,10 +28,17 @@ from vikingbot.hooks import HookContext
from vikingbot.hooks.manager import hook_manager
from vikingbot.integrations.langfuse import LangfuseClient
from 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 LLMProvider
from vikingbot.sandbox import SandboxManager
from 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_content
from vikingbot.utils.tracing import set_response_id, trace
if TYPE_CHECKING:
@@ -140,6 +147,7 @@ class AgentLoop:
self._mcp_stack: AsyncExitStack | None = None
self._mcp_connected = False
self._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 messages
if 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}",
+ }
+ )
continue
except 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 original
session_clone = session.clone()
keep_count = min(10, max(2, self.memory_window // 2))
@@ -634,8 +922,6 @@ class AgentLoop:
# Run consolidation in background
await 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_completed
await 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 content
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 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.py
index 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 = 50
memory_window: int = 50
+ session_context_enabled: bool = False
+ session_context_token_budget: int = 3000
+ commit_token_threshold: int = 20000
+ commit_keep_recent_count: int = 5
gen_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.py
index 4222ef675..ed916273a 100644
--- a/bot/vikingbot/heartbeat/service.py
+++ b/bot/vikingbot/heartbeat/service.py
@@ -175,8 +175,6 @@ class HeartbeatService:
active_workspaces = 0
for 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.py
index 18810b0ad..a44325aa4 100644
--- a/bot/vikingbot/hooks/builtins/openviking_hooks.py
+++ b/bot/vikingbot/hooks/builtins/openviking_hooks.py
@@ -1,11 +1,21 @@
import asyncio
import re
from collections import defaultdict
+from datetime import datetime
from typing import Any
from loguru import logger
from 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_tokens
from ...session import Session
from ..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.py
index a78b918b3..e80aa2177 100644
--- a/bot/vikingbot/hooks/manager.py
+++ b/bot/vikingbot/hooks/manager.py
@@ -1,7 +1,7 @@
import asyncio
import importlib
from collections import defaultdict
-from typing import List, Any, Dict, Type
+from typing import Any, Dict, List, Type
from 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.py
index 6aa6af21a..051ffbd55 100644
--- a/bot/vikingbot/openviking_mount/ov_server.py
+++ b/bot/vikingbot/openviking_mount/ov_server.py
@@ -1,6 +1,5 @@
import asyncio
import hashlib
-import time
from typing import Any, Dict, List, Optional
from 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.py
new file mode 100644
index 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.py
index bd3bb41b1..9e401f038 100644
--- a/bot/vikingbot/session/manager.py
+++ b/bot/vikingbot/session/manager.py
@@ -303,7 +303,9 @@ class SessionManager:
continue
current = 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.py
index 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.py
index 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.py
index 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.py
index 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.py
index 9d47dc7e1..08cde9425 100644
--- a/openviking_cli/client/base.py
+++ b/openviking_cli/client/base.py
@@ -264,9 +264,19 @@ class BaseClient(ABC):
@abstractmethod
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)."""
+ """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.
+ """
...
@abstractmethod
diff --git a/openviking_cli/client/http.py b/openviking_cli/client/http.py
index 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.py
index 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.py
index 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_client
diff --git a/tests/session/test_session_commit.py b/tests/session/test_session_commit.py
index 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, MagicMock
import pytest
from openviking import AsyncOpenViking
+from openviking.client.session import Session as ClientSession
from openviking.message import TextPart
from openviking.service.task_tracker import get_task_tracker
from 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.py
index 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 AsyncOpenViking
from openviking.message import ContextPart, TextPart, ToolPart
from 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"""