Skip to content

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

feat(session): add account namespace policy and shared sessions (#1356)

Qin Haojiecebc45907b02
diff --git a/crates/ov_cli/src/client.rs b/crates/ov_cli/src/client.rs
index 3da6e3777..178409fc9 100644
--- a/crates/ov_cli/src/client.rs
+++ b/crates/ov_cli/src/client.rs
@@ -45,6 +45,14 @@ impl HttpClient {
}
}
+ pub fn user_id(&self) -> Option<&str> {
+ self.user.as_deref()
+ }
+
+ pub fn agent_id(&self) -> Option<&str> {
+ self.agent_id.as_deref()
+ }
+
/// Zip a directory to a temporary file
fn zip_directory(&self, dir_path: &Path) -> Result<NamedTempFile> {
if !dir_path.is_dir() {
diff --git a/docs/design/account-namespace-shared-session-design.md b/docs/design/account-namespace-shared-session-design.md
new file mode 100644
index 000000000..c9f7a9cb1
--- /dev/null
+++ b/docs/design/account-namespace-shared-session-design.md
@@ -0,0 +1,1007 @@
+# Account 级 User / Agent 命名空间策略与共享 Session 设计方案
+
+## Context
+
+当前 OpenViking 已具备 `account_id / user_id / agent_id` 三元身份模型,但 `user` 与 `agent` 的关系语义仍然不够明确,`session`、目录和检索对这层关系的表达也不一致,主要问题有:
+
+- 系统内缺少 account 级显式策略来定义 `user scope` 是否再按 `agent` 切分、`agent scope` 是否再按 `user` 切分
+- 命名空间决策分散在多处,目录拓扑无法直接体现 `user` / `agent` 关系
+- `session` 仍然偏向单 user 视角,不能准确表达一个 account 内多 user / 多 agent 协同场景中的真实参与者身份
+- 检索、目录遍历、向量索引、消息身份模型之间缺少一套统一的 owner / participant 语义
+
+本次方案的目标,是把 `user` / `agent` 关系显式提升为 account 级命名空间策略,并为后续混合参与者 session 的提取、审计和协同能力打基础。
+
+---
+
+## 决策摘要
+
+- account 级新增两项配置:
+ - `isolate_user_scope_by_agent: bool`
+ - `isolate_agent_scope_by_user: bool`
+- 默认值:
+ - `isolate_user_scope_by_agent = false`
+ - `isolate_agent_scope_by_user = false`
+- `user` 与 `agent` 目录都采用显式嵌套 canonical URI,不再依赖 hash space。
+- `session` 升级为 account 级共享作用域,统一落在:
+ - `viking://session/{session_id}`
+- `session add-message` 新增 `role_id`:
+ - `role=user` 时绑定真实 `user_id`
+ - `role=assistant` 时绑定真实 `agent_id`
+- 检索与目录可见性统一基于以下信息:
+ - `account_id`
+ - `uri`
+ - `owner_user_id`
+ - `owner_agent_id`
+- 本方案按不兼容改造设计:
+ - 不做旧命名空间兼容
+ - 不做历史数据迁移
+ - 不做 mixed session `commit / extract` 分流
+
+---
+
+## 一、目标与非目标
+
+### 1.1 目标
+
+- 引入 account 级配置,显式定义 `user` 和 `agent` 的共享边界
+- 统一 `user / agent / session` 的逻辑 URI 与底层目录拓扑
+- 将 `session` 升级为 account 级共享会话
+- 在 `session add-message` 中显式记录消息归属身份
+- 统一文件系统可见性与检索过滤规则,避免“能搜到但不能读”
+
+### 1.2 非目标
+
+- 本次不实现历史数据迁移
+- 本次不实现双读双写兼容
+- 本次不定义混合参与者 session 的 `commit / extract` 分流算法
+- 本次不引入 participant 级 ACL,只提供 account 级共享 session
+
+---
+
+## 二、核心设计决策
+
+### 2.1 account 级配置字段
+
+推荐字段名:
+
+- `isolate_user_scope_by_agent: bool`
+- `isolate_agent_scope_by_user: bool`
+
+语义如下:
+
+- `isolate_user_scope_by_agent = false`
+ - `user` 作用域只按 `user_id` 分区
+- `isolate_user_scope_by_agent = true`
+ - `user` 作用域按 `(user_id, agent_id)` 分区
+- `isolate_agent_scope_by_user = false`
+ - `agent` 作用域只按 `agent_id` 分区
+- `isolate_agent_scope_by_user = true`
+ - `agent` 作用域按 `(agent_id, user_id)` 分区
+
+默认值:
+
+- `isolate_user_scope_by_agent = false`
+- `isolate_agent_scope_by_user = false`
+
+这个默认值的含义是:
+
+- `user` 记忆按 user 隔离,不区分 agent
+- `agent` 记忆按 agent 隔离,不区分 user
+
+采用这个默认值的原因是:
+
+- 大多数产品里,用户画像、偏好、个人事实更自然地跟 `user` 绑定,应该能跨 agent 复用
+- 很多 agent 在系统内更像“共享能力单元”而不是“每个 user 一份的私有副本”,默认跨 user 共享更符合直觉
+- 把两者都默认设为“不额外切分”,可以让目录语义最直接,减少初期理解和使用成本
+
+### 2.2 配置方式与生命周期
+
+这两个字段在 account 创建时配置,并跟随 account 生命周期持久化。
+
+持久化位置:
+
+- `/local/{account_id}/_system/setting.json`
+
+示例:
+
+```json
+{
+ "namespace": {
+ "isolate_user_scope_by_agent": false,
+ "isolate_agent_scope_by_user": false
+ }
+}
+```
+
+配置入口:
+
+- `POST /api/v1/admin/accounts`
+
+请求示例:
+
+```json
+{
+ "account_id": "acme",
+ "admin_user_id": "alice",
+ "isolate_user_scope_by_agent": false,
+ "isolate_agent_scope_by_user": false
+}
+```
+
+如果请求里省略这两个字段,则服务端按默认值补齐:
+
+```json
+{
+ "isolate_user_scope_by_agent": false,
+ "isolate_agent_scope_by_user": false
+}
+```
+
+读取入口:
+
+- `GET /api/v1/admin/accounts`
+- `GET /api/v1/admin/accounts/{account_id}`(如果后续补充单 account 查询接口)
+
+持久化要求:
+
+- account 创建时,服务端将这两个字段写入 `/{account_id}/_system/setting.json` 的 `namespace` 节点
+- 服务启动后加载 account 配置时,这两个字段进入 `AccountNamespacePolicy`
+- 后续所有 URI 解析、目录初始化、检索过滤、session 可见性都只能读取这一个来源
+
+修改策略:
+
+- 本阶段不提供 account policy 更新接口
+- account 创建完成后,这两个字段视为不可变
+- 不支持通过手工修改 `setting.json` 的方式在线切换 policy
+
+原因:
+
+- 修改任一字段都会改变 canonical URI 结构
+- 已有目录路径、索引字段、session 派生引用都会跟着变化
+- 在没有迁移工具、校验工具和回滚策略之前,不应支持在线修改
+
+如果后续业务确实需要调整:
+
+- 方案一:新建 account,按新 policy 初始化,再做数据迁移
+- 方案二:单独立项做离线迁移,不通过常规 admin API 在线修改
+
+### 2.3 配置生效层级
+
+这两个字段只在 `account` 上定义,不在 `user`、`agent`、`session` 或请求级覆盖。
+
+原因:
+
+- 命名空间拓扑属于 account 级存储契约,不适合在请求级动态切换
+- 一旦允许运行时切换,就会导致同一 account 内路径布局和检索过滤规则不稳定
+- 统一到 account 级后,目录、索引、权限判断才能保持一致
+
+---
+
+## 三、命名空间模型
+
+### 3.1 总体原则
+
+- 逻辑 URI 采用显式嵌套路径,不再依赖不可读的 hash space
+- `user`、`agent`、`session` 都有 canonical URI
+- 简写 URI 可以保留,但内部必须先 canonicalize,再进入存储、检索和权限判断
+
+### 3.2 四种拓扑矩阵
+
+#### `isolate_user_scope_by_agent=false`,`isolate_agent_scope_by_user=false`
+
+```text
+viking://user/{user_id}/...
+viking://agent/{agent_id}/...
+viking://session/{session_id}/...
+```
+
+底层目录:
+
+```text
+/local/{account_id}/user/{user_id}/...
+/local/{account_id}/agent/{agent_id}/...
+/local/{account_id}/session/{session_id}/...
+```
+
+访问规则:
+
+- 当前请求身份为 `(user_id=ua, agent_id=aa)` 时,可以访问 `viking://user/ua/...` 下的全部 user 数据,不受当前 agent 影响
+- 当前请求身份为 `(user_id=ua, agent_id=aa)` 时,可以访问 `viking://agent/aa/...` 下的全部 agent 数据,不受当前 user 影响
+- 不能访问其他 user 的 `viking://user/{other_user_id}/...`
+- 不能访问其他 agent 的 `viking://agent/{other_agent_id}/...`
+- `session` 按 account 共享,访问规则独立于这两个字段
+
+适用场景:
+
+- 一个 account 内多个 user 共同使用一组标准化 agent,且 agent 的技能、案例、工作区都希望在团队内共享
+- 用户侧资料也希望跨 agent 复用,例如统一的用户画像、偏好、长期事实
+- 更适合协作型工作区,而不是强隔离场景
+
+#### `isolate_user_scope_by_agent=false`,`isolate_agent_scope_by_user=true`
+
+```text
+viking://user/{user_id}/...
+viking://agent/{agent_id}/user/{user_id}/...
+viking://session/{session_id}/...
+```
+
+底层目录:
+
+```text
+/local/{account_id}/user/{user_id}/...
+/local/{account_id}/agent/{agent_id}/user/{user_id}/...
+/local/{account_id}/session/{session_id}/...
+```
+
+访问规则:
+
+- 当前请求身份为 `(user_id=ua, agent_id=aa)` 时,可以访问 `viking://user/ua/...` 下的全部 user 数据,不受当前 agent 影响
+- 当前请求身份为 `(user_id=ua, agent_id=aa)` 时,只能访问 `viking://agent/aa/user/ua/...`
+- 不能访问 `viking://agent/aa/user/{other_user_id}/...`
+- 不能访问 `viking://agent/{other_agent_id}/user/ua/...`
+- `session` 按 account 共享,访问规则独立于这两个字段
+
+适用场景:
+
+- 同一个 user 会在多个 agent 之间切换,希望个人资料和长期偏好能直接复用
+- 不同 user 虽然可能使用同名 agent,但 agent 的案例、instructions、技能配置等沉淀需要彼此隔离
+- 适合希望保留 user 侧共享,但对 agent 侧共享更谨慎的部署方式
+
+#### `isolate_user_scope_by_agent=true`,`isolate_agent_scope_by_user=false`
+
+```text
+viking://user/{user_id}/agent/{agent_id}/...
+viking://agent/{agent_id}/...
+viking://session/{session_id}/...
+```
+
+底层目录:
+
+```text
+/local/{account_id}/user/{user_id}/agent/{agent_id}/...
+/local/{account_id}/agent/{agent_id}/...
+/local/{account_id}/session/{session_id}/...
+```
+
+访问规则:
+
+- 当前请求身份为 `(user_id=ua, agent_id=aa)` 时,只能访问 `viking://user/ua/agent/aa/...`
+- 不能访问 `viking://user/ua/agent/{other_agent_id}/...`
+- 当前请求身份为 `(user_id=ua, agent_id=aa)` 时,可以访问 `viking://agent/aa/...` 下的全部 agent 数据,不受当前 user 影响
+- 不能访问其他 agent 的 `viking://agent/{other_agent_id}/...`
+- `session` 按 account 共享,访问规则独立于这两个字段
+
+适用场景:
+
+- agent 本身代表某种共享岗位能力或团队能力,希望其案例、技能、instructions 等沉淀在所有 user 之间复用
+- 但同一个 user 在不同 agent 下的个人资料或用户记忆不希望互通
+- 适合“agent 是主实体,user 只是调用者”的平台型场景
+
+#### `isolate_user_scope_by_agent=true`,`isolate_agent_scope_by_user=true`
+
+```text
+viking://user/{user_id}/agent/{agent_id}/...
+viking://agent/{agent_id}/user/{user_id}/...
+viking://session/{session_id}/...
+```
+
+底层目录:
+
+```text
+/local/{account_id}/user/{user_id}/agent/{agent_id}/...
+/local/{account_id}/agent/{agent_id}/user/{user_id}/...
+/local/{account_id}/session/{session_id}/...
+```
+
+访问规则:
+
+- 当前请求身份为 `(user_id=ua, agent_id=aa)` 时,只能访问 `viking://user/ua/agent/aa/...`
+- 不能访问 `viking://user/ua/agent/{other_agent_id}/...`
+- 当前请求身份为 `(user_id=ua, agent_id=aa)` 时,只能访问 `viking://agent/aa/user/ua/...`
+- 不能访问 `viking://agent/aa/user/{other_user_id}/...`
+- 不能访问 `viking://agent/{other_agent_id}/user/ua/...`
+- `session` 按 account 共享,访问规则独立于这两个字段
+
+适用场景:
+
+- 每个 `(user, agent)` 组合都应视为独立工作单元,不能共享任何用户记忆或 agent 沉淀
+- 强合规、强审计、强租户内隔离场景
+- 适合外包、敏感业务、或需要最小共享面的部署方式
+
+### 3.3 scope 内部结构
+
+#### user scope
+
+```text
+memories/
+ preferences/
+ entities/
+ events/
+profile.md
+```
+
+#### agent scope
+
+```text
+memories/
+ cases/
+ patterns/
+skills/
+instructions/
+```
+
+#### session scope
+
+```text
+messages.jsonl
+history/
+tools/
+.meta.json
+```
+
+### 3.4 简写 URI 规则
+
+保留如下简写:
+
+- `viking://user/...`
+- `viking://agent/...`
+
+但内部一律按当前 account policy 和请求身份展开为 canonical URI。
+
+示例:当前身份为 `(account=acme, user=ua, agent=aa)`
+
+当 `isolate_user_scope_by_agent=false` 时:
+
+```text
+viking://user/memories/preferences/
+=> viking://user/ua/memories/preferences/
+```
+
+当 `isolate_user_scope_by_agent=true` 时:
+
+```text
+viking://user/memories/preferences/
+=> viking://user/ua/agent/aa/memories/preferences/
+```
+
+当 `isolate_agent_scope_by_user=false` 时:
+
+```text
+viking://agent/memories/cases/
+=> viking://agent/aa/memories/cases/
+```
+
+当 `isolate_agent_scope_by_user=true` 时:
+
+```text
+viking://agent/memories/cases/
+=> viking://agent/aa/user/ua/memories/cases/
+```
+
+要求:
+
+- 存储层只处理 canonical URI
+- 向量索引写入只处理 canonical URI
+- 权限判断只处理 canonical URI
+
+---
+
+## 四、Session 模型重构
+
+### 4.1 Session 作用域调整
+
+将 `session` 从 user 目录下移出,统一为 account 级共享:
+
+```text
+viking://session/{session_id}
+```
+
+底层目录:
+
+```text
+/local/{account_id}/session/{session_id}
+```
+
+设计原因:
+
+- 同一 account 内可能有多个 user / agent 共同参与一个会话
+- 把 session 绑定在某个 user 根目录下,会让会话共享变得别扭
+- session 作为临时协作容器,更适合按 account 共享,再通过消息身份描述参与者
+
+### 4.2 Session 可见性与权限
+
+推荐权限:
+
+- `create / list / get / add-message / commit`
+ - 同 account 内可访问
+- `delete`
+ - 仅 `ADMIN`
+ - 或 `ROOT`
+
+这意味着:
+
+- session 可被 account 内其他 user 看到和继续使用
+- 删除权限单独收紧,避免 shared session 的“所有者”语义不清
+
+### 4.3 Session 元数据
+
+`session/.meta.json` 新增字段:
+
+- `created_by_user_id`
+- `participant_user_ids`
+- `participant_agent_ids`
+
+说明:
+
+- `created_by_user_id` 表示“这个 session 最初是由哪个请求身份创建出来的”
+- 写入时机:
+ - 第一次真正创建 session 时写入 `.meta.json`
+ - 具体包括 `POST /api/v1/sessions` 创建
+ - 以及未来如果保留 `auto_create` 语义,则第一次自动创建时也写入
+- 写入来源:
+ - 直接取创建请求对应的 `RequestContext.user.user_id`
+ - 也就是发起这次创建操作的请求用户
+- 一旦写入,不再随着后续 `add-message` 的 `role_id` 变化而变化
+- 它是审计字段,不直接参与删除权限判断
+- `participant_*` 只用于索引、展示、后续提取分流,不承担 ACL
+
+也就是说:
+
+- `created_by_user_id` 不是客户端额外传的参数
+- 它是服务端在“创建 session 的那一刻”从当前登录身份里自动记下来的
+- 它和消息里的 `role_id` 不是一回事
+ - `created_by_user_id` 解决“这个 session 最初由谁创建”
+ - `role_id` 解决“这条消息是谁说的”
+
+---
+
+### 4.4 `add-message` 接口扩展
+
+在 `POST /api/v1/sessions/{session_id}/messages` 中新增 `role_id`。
+
+示例:
+
+```json
+{
+ "role": "user",
+ "role_id": "ua",
+ "content": "你好"
+}
+```
+
+```json
+{
+ "role": "assistant",
+ "role_id": "aa",
+ "parts": [...]
+}
+```
+
+规则:
+
+- `role == "user"` 时,`role_id` 表示真实 `user_id`
+- `role == "assistant"` 时,`role_id` 表示真实 `agent_id`
+- 其他 role 暂不使用 `role_id`
+
+### 4.5 请求头语义与 `RequestContext` 解析
+
+服务端需要区分“真实调用者身份”和“本次请求按谁的视角执行”。
+
+在不同认证模式下,`X-OpenViking-Account`、`X-OpenViking-User`、`X-OpenViking-Agent` 的语义如下:
+
+- `trusted` 模式
+ - `X-OpenViking-Account / User / Agent` 表示真实调用者身份
+ - 此时不存在模拟其他用户身份的语义
+
+- `api_key + ROOT`
+ - `X-OpenViking-Account / User / Agent` 表示本次请求的生效上下文
+ - `ROOT` 可以显式指定本次请求作用到哪个 account / user / agent
+
+- `api_key + ADMIN`
+ - `X-OpenViking-User / Agent` 表示本次请求的生效 user / agent 上下文
+ - `ADMIN` 只能在自己的 account 内使用这组请求头模拟用户视角
+ - `ADMIN` 不允许通过 `X-OpenViking-Account` 切换到其他 account
+
+- `api_key + USER`
+ - `user_id` 只能从当前 user key 对应的身份解析
+ - `X-OpenViking-Agent` 仍可用于指定当前请求的 agent 上下文
+ - `USER` 不允许通过 `X-OpenViking-User` 切换到其他 user
+
+`RequestContext` 的语义统一为:
+
+- `ctx.user` 表示本次请求的生效身份
+- `ctx.role` 表示真实调用者角色
+- namespace 解析、检索过滤、文件系统可见性都按 `ctx.user` 执行
+- 管理权限按 `ctx.role` 判断
+
+### 4.6 `add-message` 校验与默认填充
+
+`role_id` 的语义如下:
+
+- `role = "user"` 时,`role_id` 表示消息所属的 `user_id`
+- `role = "assistant"` 时,`role_id` 表示消息所属的 `agent_id`
+
+校验与填充规则:
+
+- `trusted`、`ROOT`、`ADMIN`
+ - 可以显式传入 `role_id`
+ - 如果未显式传入:
+ - `role = "user"` 时,默认填充 `ctx.user.user_id`
+ - `role = "assistant"` 时,默认填充 `ctx.user.agent_id`
+
+- `USER`
+ - 不接受显式传入的 `role_id`
+ - `role_id` 只能从 `ctx` 推导
+ - 具体规则为:
+ - `role = "user"` 时,写入 `ctx.user.user_id`
+ - `role = "assistant"` 时,写入 `ctx.user.agent_id`
+
+额外约束:
+
+- `role = "user"` 时,最终写入的 `role_id` 必须是当前 account 下合法的 `user_id`
+- `role = "assistant"` 时,最终写入的 `role_id` 作为 `agent_id` 使用
+- 本阶段不引入独立的 agent registry;因此对 `assistant.role_id` 只做格式和上下文一致性校验
+
+### 4.7 消息持久化结构
+
+`Message` 增加字段:
+
+```json
+{
+ "id": "msg_xxx",
+ "role": "assistant",
+ "role_id": "aa",
+ "parts": [...],
+ "created_at": "2026-04-09T10:00:00Z"
+}
+```
+
+`role_id` 表示这条消息的 actor 身份,不等于真实调用者身份。后续从消息派生 tool / skill / memory 归属时,应以消息自身的 `role + role_id` 为准。
+
+### 4.8 Session 派生 URI
+
+`tool_uri` 统一调整为:
+
+```text
+viking://session/{session_id}/tools/{tool_id}
+```
+
+后续凡是从 message 中派生 tool / skill / memory 归属时,都应优先使用消息上的 `role + role_id`,而不是默认使用当前请求上下文里的 agent / user。
+
+
+---
+
+## 五、检索、文件系统与可见性
+
+### 5.1 问题
+
+当前很多逻辑依赖单一字符串字段 `owner_space`。这个字段在以下场景下不够稳定:
+
+- 命名空间拓扑有四种组合
+- session 改成 account 共享后,不能再把 session 误归到 user owner
+- user/agent 简写 URI 需要展开
+- 仅靠一个字符串,不方便做结构化可见性判断
+
+### 5.2 索引中的归属信息
+
+向量索引和 `Context` 的归属字段调整为:
+
+- 保留已有字段:
+ - `account_id`
+ - `uri`
+- 新增字段:
+ - `owner_user_id`
+ - `owner_agent_id`
+- 移除字段:
+ - `owner_scope`
+
+其中:
+
+- `uri` 使用标准路径
+- `scope` 从 `uri` 的前缀解析得到,不单独存 `owner_scope`
+- `owner_user_id` / `owner_agent_id` 用来表达这条数据绑定到哪个 user / agent
+- `uri` 和 `owner_user_id` / `owner_agent_id` 需要保持一致,不能互相冲突
+
+### 5.3 写入规则
+
+所有写入到索引的数据,都必须先确定标准 URI,再由标准 URI 生成 `owner_user_id` / `owner_agent_id`。
+
+写入时规则如下:
+
+#### resource
+
+```text
+uri = viking://resources/...
+owner_user_id = null
+owner_agent_id = null
+```
+
+#### user scope
+
+```text
+uri = viking://user/{user_id}/... if isolate_user_scope_by_agent = false
+uri = viking://user/{user_id}/agent/{agent_id}/... if isolate_user_scope_by_agent = true
+
+owner_user_id = user_id
+owner_agent_id = null if isolate_user_scope_by_agent = false
+owner_agent_id = agent_id if isolate_user_scope_by_agent = true
+```
+
+#### agent scope
+
+```text
+uri = viking://agent/{agent_id}/... if isolate_agent_scope_by_user = false
+uri = viking://agent/{agent_id}/user/{user_id}/... if isolate_agent_scope_by_user = true
+
+owner_agent_id = agent_id
+owner_user_id = null if isolate_agent_scope_by_user = false
+owner_user_id = user_id if isolate_agent_scope_by_user = true
+```
+
+#### session
+
+```text
+uri = viking://session/{session_id}/...
+owner_user_id = null
+owner_agent_id = null
+```
+
+### 5.4 查询过滤规则
+
+检索时先加:
+
+```text
+account_id == ctx.account_id
+```
+
+然后根据当前 `(user_id, agent_id)` 和 account policy,算出本次请求可见的路径根:
+
+#### resource 根路径
+
+```text
+viking://resources/
+```
+
+#### session 根路径
+
+```text
+viking://session/
+```
+
+#### user 根路径
+
+```text
+viking://user/{user_id}/... if isolate_user_scope_by_agent = false
+viking://user/{user_id}/agent/{agent_id}/... if isolate_user_scope_by_agent = true
+```
+
+#### agent 根路径
+
+```text
+viking://agent/{agent_id}/... if isolate_agent_scope_by_user = false
+viking://agent/{agent_id}/user/{user_id}/... if isolate_agent_scope_by_user = true
+```
+
+检索过滤由两部分组成:
+
+- `account_id == ctx.account_id`
+- `uri` 必须落在上述可见根路径下
+- `owner_user_id` / `owner_agent_id` 必须满足当前 policy 对应的可见范围
+
+如果请求显式传了 `target_uri`,则:
+
+- 先把 `target_uri` 归一化成标准路径
+- 校验该 `target_uri` 是否在当前请求可见范围内
+- 再把检索范围收敛到该 `target_uri` 前缀下
+
+说明:
+
+- session 在本方案中按 account 共享,因此统一落在 `viking://session/`
+- `uri` 用来表达真实路径范围
+- `owner_user_id` / `owner_agent_id` 用来表达绑定到哪个 user / agent
+- 文件系统可见性与检索过滤必须复用同一套判断规则
+
+### 5.5 结果校验与错误处理
+
+检索返回后,服务端仍需对命中结果做一次基于 `uri + owner_user_id + owner_agent_id` 的一致性校验,避免索引脏数据或历史遗留数据泄漏。
+
+错误处理如下:
+
+- `target_uri` 路径形状和当前 policy 不匹配:返回 `400`
+- `target_uri` 本身形状没问题,但当前身份无权访问:返回 `403`
+- 不传 `target_uri` 时,按当前身份可见范围做全局检索
+
+---
+
+### 5.6 文件系统与目录初始化
+
+#### VikingFS
+
+需要引入统一的 namespace resolver,承担以下职责:
+
+- 根据 account policy + 当前身份生成 canonical user / agent 根路径
+- 将简写 URI canonicalize
+- 解析 URI 对应的 owner 结构
+- 判断路径是否对当前 `(account_id, user_id, agent_id)` 可见
+
+`VikingFS` 的以下能力都需要切到新规则:
+
+- `_uri_to_path`
+- `_path_to_uri`
+- `_is_accessible`
+- `ls / tree / stat / read / write`
+
+#### DirectoryInitializer
+
+目录初始化要区分两类节点:
+
+- 真实作用域根
+ - 需要生成 `memories / skills / instructions` 等预置结构
+- 中间容器目录
+ - 只承担路径承载作用
+ - 不重复写入预置抽象与 overview
+
+例如在 `isolate_user_scope_by_agent=true` 且 `isolate_agent_scope_by_user=true` 下:
+
+```text
+viking://agent/{agent_id}
+```
+
+只是容器;
+
+```text
+viking://agent/{agent_id}/user/{user_id}
+```
+
+才是实际的 agent scope 根。
+
+---
+
+## 六、接口与类型变更
+
+### 6.1 Admin API
+
+`POST /api/v1/admin/accounts` 新增:
+
+- `isolate_user_scope_by_agent`
+- `isolate_agent_scope_by_user`
+
+`GET /api/v1/admin/accounts` 返回同样两项配置。
+
+account 级 namespace policy 持久化在:
+
+- `/local/{account_id}/_system/setting.json`
+
+文件示例:
+
+```json
+{
+ "namespace": {
+ "isolate_user_scope_by_agent": false,
+ "isolate_agent_scope_by_user": false
+ }
+}
+```
+
+如果创建请求未显式传值,则服务端使用默认值:
+
+- `isolate_user_scope_by_agent = false`
+- `isolate_agent_scope_by_user = false`
+
+本阶段不提供修改 account policy 的更新接口。
+
+原因:
+
+- 修改 policy 本质上是重排目录和索引
+- 没有迁移机制前,不应允许运行时修改
+- 直接手工修改 `setting.json` 也不在支持范围内
+
+### 6.2 核心类型
+
+需要扩展:
+
+- `AccountInfo`
+- `ResolvedIdentity`
+- `RequestContext`
+- `Message`
+- `SessionMeta`
+- `Context`
+
+## 七、影响模块
+
+本次方案预计影响如下模块族:
+
+- 多租户与认证
+ - account 配置读写
+ - auth middleware
+ - request context
+- 命名空间解析
+ - `UserIdentifier`
+ - 新增统一 resolver / policy
+- 文件系统
+ - `VikingFS`
+ - `DirectoryInitializer`
+- session
+ - `Session`
+ - `SessionService`
+ - `sessions router`
+ - `Message`
+- 检索与向量
+ - `Context`
+ - embedding message converter
+ - semantic processor
+ - collection schema
+ - vector backend filter
+- 接入层
+ - Python SDK
+ - HTTP client
+ - Rust CLI
+
+---
+
+## 八、兼容性策略
+
+本次不采用“全量兼容”或“双读双写”策略,而是按 scope 分别处理:
+
+### 8.1 user scope
+
+- `user` 侧默认路径本身就是 `viking://user/{user_id}/...`
+- 如果新拓扑仍然采用 user 共享形态,则 AGFS 路径天然兼容
+- 因此本阶段不对 `user` 侧做目录迁移
+
+### 8.2 session scope
+
+- `session` 只在 AGFS 中维护,不进入 VectorDB
+- 在确认 account 内不存在同名 `session_id` 的前提下,session 迁移按纯目录移动处理:
+
+```text
+viking://session/{user_id}/{session_id}
+-> viking://session/{session_id}
+```
+
+- 本阶段不保留旧 session 根路径兼容读
+- 迁移完成后,session 的 list / get / delete / add-message / commit 全部只认新路径
+
+### 8.3 agent scope
+
+- 本次不支持旧 agent 数据自动迁移到新命名空间
+- 不保留旧 hash namespace 的兼容访问
+- 不继续让 `memory.agent_scope_mode` 参与服务端命名空间决策
+- 如需保留旧 agent 数据,可在升级前自行使用现有 `ovpack` 做离线备份
+
+推荐迁移方式:
+
+- 升级前:在旧版本中从 legacy hash namespace 导出,例如:
+
+```bash
+ov export viking://agent/{legacy_agent_space_hash}/memories ./agent_memory.ovpack
+```
+
+- 升级后:在新版本中按目标 account policy 导入到 agent space 的父目录:
+
+```bash
+# isolate_agent_scope_by_user = false
+ov import ./agent_memory.ovpack viking://agent/{agent_id}/ --force
+
+# isolate_agent_scope_by_user = true
+ov import ./agent_memory.ovpack viking://agent/{agent_id}/user/{user_id}/ --force
+```
+
+- 不要把 `.ovpack` 直接导入到 `.../memories/` 本身,否则会得到 `.../memories/memories/...`
+- 当 `isolate_agent_scope_by_user = true` 时,`viking://agent/{agent_id}/user/` 不是合法目标;必须显式提供 `user_id`
+
+原因:
+
+- 当前 agent root 是 hash space,而不是显式 `agent_id`
+- hash 值不能从结果稳定反推出原始 `user_id / agent_id`
+- 如果目标拓扑还涉及 agent 共享,会进一步引入多份旧数据合并问题
+
+### 8.4 总体取舍
+
+本次兼容策略总结如下:
+
+- `user`:天然兼容,不迁
+- `session`:直接 `mv`
+- `agent`:不自动兼容,只提供 ovpack 导出
+
+这个取舍的目的是把新命名空间模型尽快收敛为单一存储契约,而不是把 legacy hash 逻辑继续带入新实现。
+
+---
+
+## 九、风险与边界
+
+### 9.1 混合参与者 session 的提取策略尚未定义
+
+当一个 session 同时包含多个 user 和多个 assistant 时,后续 `commit / extract` 如何分流到对应 user / agent 作用域,是独立问题。
+
+本次只解决:
+
+- 会话可以共享
+- 每条消息的参与者身份可追踪
+- 检索与目录可见性有稳定 owner 语义
+
+### 9.2 session 共享不等于 participant ACL
+
+本方案采用 account 级共享 session。也就是说,同 account 内用户都可以看见 session。
+
+如果未来需要“仅参与者可见”的 session,需要额外引入 participant ACL 模型,这不在本次范围内。
+
+### 9.3 拓扑切换不可在线修改
+
+一旦 account 已有数据,切换 `isolate_user_scope_by_agent` 或 `isolate_agent_scope_by_user` 会导致:
+
+- 目录 root 变化
+- 索引字段变化
+- 检索过滤条件变化
+
+因此本阶段不支持在线修改。
+
+---
+
+## 十、测试方案
+
+### 10.1 account policy
+
+- 创建 account 时两项配置写入成功
+- list account 能返回两项配置
+- 默认值为 `false / false`
+- 四种组合可正确加载
+
+### 10.2 namespace matrix
+
+- `user` / `agent` canonical URI 生成正确
+- 简写 URI 展开正确
+- 四种拓扑下底层目录映射正确
+- 中间容器目录与真实作用域根区分正确
+
+### 10.3 session
+
+- session 根路径为 `viking://session/{session_id}`
+- session list 为 account 级
+- `role_id` 校验正确
+- `Message.role_id` 持久化正确
+- `participant_user_ids` / `participant_agent_ids` 正确累积
+- `ADMIN / ROOT` 删除权限正确
+
+### 10.4 retrieval / visibility
+
+- FS `ls / stat / read` 与检索结果一致
+- user scope 在四种 policy 下可见性正确
+- agent scope 在四种 policy 下可见性正确
+- session scope 按 account 共享
+- cross-account 不泄漏
+
+### 10.5 negative cases
+
+- 缺失 `role_id`
+- 非法 nested URI
+- policy 与路径不匹配
+- 尝试访问非本 user / agent 可见作用域
+
+---
+
+## 十一、推荐落地顺序
+
+建议按以下顺序实施:
+
+1. 引入 account policy 与统一 namespace resolver
+2. 改造 `UserIdentifier`、`RequestContext`、Admin API
+3. 改造 `VikingFS` 与目录初始化
+4. 改造 `session` 路径与 `Message.role_id`
+5. 改造 `Context`、embedding、vector schema 与过滤逻辑
+6. 最后更新 SDK / CLI 与文档
+
+这样可以先把“路径与身份语义”固定,再去改造检索与接入层,风险更可控。
+
+---
+
+## 结论
+
+本方案的核心是把 `user`、`agent` 的共享关系显式提升为 account 级策略,并将 `session` 升级为 account 级共享容器,再用 `role_id` 和标准 URI 把消息、目录和检索统一到同一套身份模型上。
+
+如果接受这份方案,后续实现应严格遵守两条主线:
+
+- 所有 URI 先 canonicalize,再进入存储、检索、权限判断
+- 所有可见性与索引判断都基于 `account_id + uri + owner_user_id + owner_agent_id`
+
+这两条一旦立住,后续 mixed session extraction、participant ACL、审计追踪才有稳定的基础。
diff --git a/docs/en/concepts/04-viking-uri.md b/docs/en/concepts/04-viking-uri.md
index 6f87e2f37..acb3ad603 100644
--- a/docs/en/concepts/04-viking-uri.md
+++ b/docs/en/concepts/04-viking-uri.md
@@ -120,7 +120,7 @@ viking://
│ ├── entities/ # Each independent
│ └── events/ # Each independent
│
-├── agent/{agent_space}/ # agent_space is derived from memory.agent_scope_mode
+├── agent/{agent_id}/ # Agent root when isolate_agent_scope_by_user = false
│ ├── skills/ # Skill definitions
│ ├── memories/
│ │ ├── cases/
@@ -128,16 +128,24 @@ viking://
│ ├── workspaces/
│ └── instructions/
│
+├── agent/{agent_id}/user/{user_id}/ # Agent root when isolate_agent_scope_by_user = true
+│ ├── skills/
+│ ├── memories/
+│ ├── workspaces/
+│ └── instructions/
+│
└── session/{user_space}/{session_id}/
├── messages/
├── tools/
└── history/
```
-The `agent_space` value depends on `memory.agent_scope_mode`:
+Agent namespace shape is controlled by per-account namespace policy:
+
+- `isolate_agent_scope_by_user = false`: `viking://agent/{agent_id}/...`
+- `isolate_agent_scope_by_user = true`: `viking://agent/{agent_id}/user/{user_id}/...`
-- `user+agent` (default): `agent_space = md5(f"{user_id}:{agent_id}")[:12]`
-- `agent`: `agent_space = md5(agent_id)[:12]`
+`memory.agent_scope_mode` is deprecated and ignored.
## URI Operations
diff --git a/docs/en/concepts/11-multi-tenant.md b/docs/en/concepts/11-multi-tenant.md
index 9684edd8d..eece0b513 100644
--- a/docs/en/concepts/11-multi-tenant.md
+++ b/docs/en/concepts/11-multi-tenant.md
@@ -41,9 +41,9 @@ With multi-tenancy enabled, you can:
`agent_id` separates agent-level space.
-- In the default mode, agent space is derived from `user_id + agent_id`
-- That means different agents for the same user can have different agent memories
-- If `memory.agent_scope_mode = "agent"`, the same `agent_id` can share agent space across users in the same account
+- Agent URI shape is controlled by per-account namespace policy
+- `isolate_agent_scope_by_user = false` means `viking://agent/{agent_id}/...`
+- `isolate_agent_scope_by_user = true` means `viking://agent/{agent_id}/user/{user_id}/...`
### Roles
@@ -84,7 +84,7 @@ If `auth_mode = "api_key"` and `root_api_key` is not configured, the server runs
|-----------|------------------------|---------------------------|----------------------------|
| `resources` | No | Yes | account |
| `user` | No | No | user |
-| `agent` | No | Depends on `memory.agent_scope_mode` | Default: `user + agent` |
+| `agent` | No | Depends on account namespace policy | Default: `agent` |
| `session` | No | No | user / session |
### Storage Layer
diff --git a/docs/en/guides/01-configuration.md b/docs/en/guides/01-configuration.md
index fa1cc4921..87fafd224 100644
--- a/docs/en/guides/01-configuration.md
+++ b/docs/en/guides/01-configuration.md
@@ -780,9 +780,9 @@ For memory-related settings, add a `memory` section in `ov.conf`:
| Field | Description | Default |
|-------|-------------|---------|
-| `agent_scope_mode` | Agent memory namespace mode: `"user+agent"` isolates by `(user_id, agent_id)`, while `"agent"` isolates only by `agent_id` and shares agent memories across users of the same agent | `"user+agent"` |
+| `agent_scope_mode` | Deprecated and ignored. Kept only for backward compatibility with older `ov.conf` files. Agent/user namespace behavior is now controlled by per-account namespace policy. | `"user+agent"` |
-`agent_scope_mode` only affects agent-level namespaces such as `viking://agent/{agent_space}/memories/...`. User memories under `viking://user/{user_space}/memories/...` are not affected.
+`agent_scope_mode` no longer changes namespace behavior. The server now uses account-level namespace policy to choose between `viking://agent/{agent_id}/...` and `viking://agent/{agent_id}/user/{user_id}/...`.
### ovcli.conf
diff --git a/docs/en/guides/09-ovpack.md b/docs/en/guides/09-ovpack.md
index 6b1189350..8f6431321 100644
--- a/docs/en/guides/09-ovpack.md
+++ b/docs/en/guides/09-ovpack.md
@@ -93,7 +93,7 @@ curl -X POST http://localhost:1933/api/v1/pack/import \
OpenViking memories are stored under fixed directory structures:
- User memories: `viking://user/{user_space}/memories/`
-- Agent memories: `viking://agent/{agent_space}/memories/`
+- Agent memories: `viking://agent/{agent_id}/memories/` or `viking://agent/{agent_id}/user/{user_id}/memories/`
When migrating memories with OVPack, you must import the `.ovpack` into the parent of the corresponding space (not an arbitrary directory). Otherwise you may end up with paths like `.../memories/memories/...`, and OpenViking will not be able to access and use them as memories.
@@ -110,8 +110,13 @@ openviking import ./exports/user-memories.ovpack viking://user/default/ --force
### Export/Import Agent Memories (CLI)
```bash
+# isolate_agent_scope_by_user = false
openviking export viking://agent/default/memories/ ./exports/agent-memories.ovpack
openviking import ./exports/agent-memories.ovpack viking://agent/default/ --force
+
+# isolate_agent_scope_by_user = true
+openviking export viking://agent/default/user/alice/memories/ ./exports/agent-memories.ovpack
+openviking import ./exports/agent-memories.ovpack viking://agent/default/user/alice/ --force
```
### Export/Import Memories (Python SDK)
diff --git a/docs/zh/concepts/04-viking-uri.md b/docs/zh/concepts/04-viking-uri.md
index 2c385a79c..c00f79a11 100644
--- a/docs/zh/concepts/04-viking-uri.md
+++ b/docs/zh/concepts/04-viking-uri.md
@@ -120,23 +120,30 @@ viking://
│ ├── entities/ # 每条独立
│ └── events/ # 每条独立
│
-├── agent/{agent_space}/ # agent_space 由 memory.agent_scope_mode 决定
+├── agent/{agent_id}/ # isolate_agent_scope_by_user = false 时的 agent 根目录
│ ├── skills/ # 技能定义
│ ├── memories/
│ │ ├── cases/
│ │ └── patterns/
│ └── instructions/
│
+├── agent/{agent_id}/user/{user_id}/ # isolate_agent_scope_by_user = true 时的 agent 根目录
+│ ├── skills/
+│ ├── memories/
+│ └── instructions/
+│
└── session/{session_id}/
├── messages/
├── tools/
└── history/
```
-其中 `agent_space` 的计算方式取决于 `memory.agent_scope_mode`:
+其中 agent 命名空间形状由 account 级 namespace policy 决定:
+
+- `isolate_agent_scope_by_user = false`:`viking://agent/{agent_id}/...`
+- `isolate_agent_scope_by_user = true`:`viking://agent/{agent_id}/user/{user_id}/...`
-- `user+agent`(默认):`agent_space = md5(f"{user_id}:{agent_id}")[:12]`
-- `agent`:`agent_space = md5(agent_id)[:12]`
+`memory.agent_scope_mode` 已废弃且被忽略。
## URI 操作
diff --git a/docs/zh/concepts/11-multi-tenant.md b/docs/zh/concepts/11-multi-tenant.md
index 2b35db7f9..5bd18710a 100644
--- a/docs/zh/concepts/11-multi-tenant.md
+++ b/docs/zh/concepts/11-multi-tenant.md
@@ -41,9 +41,9 @@ OpenViking 的多租户不是“为每个团队部署一套独立服务”,而
`agent_id` 用于区分 agent 级空间。
-- 默认模式下,agent space 由 `user_id + agent_id` 共同决定
-- 这意味着同一用户的不同 agent 可以拥有不同 agent 记忆
-- 如果 `memory.agent_scope_mode = "agent"`,则同一 `agent_id` 可在同 account 内跨用户共享 agent 空间
+- Agent URI 形状由 account 级 namespace policy 决定
+- `isolate_agent_scope_by_user = false` 时使用 `viking://agent/{agent_id}/...`
+- `isolate_agent_scope_by_user = true` 时使用 `viking://agent/{agent_id}/user/{user_id}/...`
### 角色
@@ -84,7 +84,7 @@ OpenViking Server 支持两种多租户相关认证模式:
|----------|---------------------|-------------------|--------------|
| `resources` | 否 | 是 | account |
| `user` | 否 | 否 | user |
-| `agent` | 否 | 视 `memory.agent_scope_mode` 而定 | 默认 `user + agent` |
+| `agent` | 否 | 由 account 级 namespace policy 决定 | 默认 `agent` |
| `session` | 否 | 否 | user / session |
### 存储层
diff --git a/docs/zh/guides/01-configuration.md b/docs/zh/guides/01-configuration.md
index cf5c58c0b..5080fde0e 100644
--- a/docs/zh/guides/01-configuration.md
+++ b/docs/zh/guides/01-configuration.md
@@ -753,9 +753,9 @@ openviking-server --config /path/to/ov.conf
| 字段 | 说明 | 默认值 |
|------|------|--------|
-| `agent_scope_mode` | Agent memory 命名空间模式:`"user+agent"` 按 `(user_id, agent_id)` 隔离;`"agent"` 仅按 `agent_id` 隔离,同一 agent 的不同用户共享 agent memory | `"user+agent"` |
+| `agent_scope_mode` | 已废弃且被忽略。仅为兼容旧版 `ov.conf` 保留。当前 agent/user 命名空间行为由 account 级 namespace policy 控制。 | `"user+agent"` |
-`agent_scope_mode` 只影响 `viking://agent/{agent_space}/memories/...` 这类 agent 级命名空间,不影响 `viking://user/{user_space}/memories/...` 下的 user memory。
+`agent_scope_mode` 不再影响命名空间行为。服务端现在根据 account 级 namespace policy 在 `viking://agent/{agent_id}/...` 与 `viking://agent/{agent_id}/user/{user_id}/...` 之间选择。
### ovcli.conf
diff --git a/docs/zh/guides/09-ovpack.md b/docs/zh/guides/09-ovpack.md
index 3b7ce01d5..a1b125a5e 100644
--- a/docs/zh/guides/09-ovpack.md
+++ b/docs/zh/guides/09-ovpack.md
@@ -104,7 +104,7 @@ curl -X POST http://localhost:1933/api/v1/pack/import \
OpenViking 的记忆会写入固定的目录结构中:
- 用户记忆:`viking://user/{user_space}/memories/`
-- Agent 记忆:`viking://agent/{agent_space}/memories/`
+- Agent 记忆:`viking://agent/{agent_id}/memories/` 或 `viking://agent/{agent_id}/user/{user_id}/memories/`
使用 OVPack 迁移记忆时,必须把 `.ovpack` 导入到对应 space 的父目录(而不是随便一个目录),否则会变成例如 `.../memories/memories/...` 的路径,OpenViking 将无法按“记忆”语义访问和使用这些文件。
@@ -121,8 +121,13 @@ openviking import ./exports/user-memories.ovpack viking://user/default/ --force
### 导出/导入 Agent 记忆(CLI)
```bash
+# isolate_agent_scope_by_user = false
openviking export viking://agent/default/memories/ ./exports/agent-memories.ovpack
openviking import ./exports/agent-memories.ovpack viking://agent/default/ --force
+
+# isolate_agent_scope_by_user = true
+openviking export viking://agent/default/user/alice/memories/ ./exports/agent-memories.ovpack
+openviking import ./exports/agent-memories.ovpack viking://agent/default/user/alice/ --force
```
### 导出/导入记忆(Python SDK)
diff --git a/examples/multi_tenant/shared_session_role_id_http.py b/examples/multi_tenant/shared_session_role_id_http.py
new file mode 100644
index 000000000..c262197df
--- /dev/null
+++ b/examples/multi_tenant/shared_session_role_id_http.py
@@ -0,0 +1,581 @@
+#!/usr/bin/env python3
+"""
+HTTP demo for shared-session + role_id semantics.
+
+This script creates 4 accounts for the namespace-policy matrix, creates one
+regular USER in each account, then runs two scenarios per account:
+
+1. `multi-user`
+ Uses an ADMIN key to switch effective user/agent context within one account,
+ and demonstrates that ADMIN may explicitly pass role_id.
+
+2. `normal-user`
+ Uses a USER key to show that role_id is derived from request context and
+ explicit role_id is rejected.
+
+Create account examples for the 4 namespace-policy combinations:
+ export URL=http://127.0.0.1:1933
+ export ROOT_KEY=<root-key>
+
+ # ff: isolate_user_scope_by_agent=false, isolate_agent_scope_by_user=false
+ curl -sS -X POST "$URL/api/v1/admin/accounts" \
+ -H "X-API-Key: $ROOT_KEY" \
+ -H "Content-Type: application/json" \
+ -d '{
+ "account_id": "demo-ff",
+ "admin_user_id": "alice",
+ "isolate_user_scope_by_agent": false,
+ "isolate_agent_scope_by_user": false
+ }'
+
+ # ft: isolate_user_scope_by_agent=false, isolate_agent_scope_by_user=true
+ curl -sS -X POST "$URL/api/v1/admin/accounts" \
+ -H "X-API-Key: $ROOT_KEY" \
+ -H "Content-Type: application/json" \
+ -d '{
+ "account_id": "demo-ft",
+ "admin_user_id": "alice",
+ "isolate_user_scope_by_agent": false,
+ "isolate_agent_scope_by_user": true
+ }'
+
+ # tf: isolate_user_scope_by_agent=true, isolate_agent_scope_by_user=false
+ curl -sS -X POST "$URL/api/v1/admin/accounts" \
+ -H "X-API-Key: $ROOT_KEY" \
+ -H "Content-Type: application/json" \
+ -d '{
+ "account_id": "demo-tf",
+ "admin_user_id": "alice",
+ "isolate_user_scope_by_agent": true,
+ "isolate_agent_scope_by_user": false
+ }'
+
+ # tt: isolate_user_scope_by_agent=true, isolate_agent_scope_by_user=true
+ curl -sS -X POST "$URL/api/v1/admin/accounts" \
+ -H "X-API-Key: $ROOT_KEY" \
+ -H "Content-Type: application/json" \
+ -d '{
+ "account_id": "demo-tt",
+ "admin_user_id": "alice",
+ "isolate_user_scope_by_agent": true,
+ "isolate_agent_scope_by_user": true
+ }'
+
+Create a regular USER for each account (the returned `result.user_key` is the key
+to use with the `normal-user` scenario):
+ curl -sS -X POST "$URL/api/v1/admin/accounts/demo-ff/users" \
+ -H "X-API-Key: $ROOT_KEY" \
+ -H "Content-Type: application/json" \
+ -d '{"user_id": "bob", "role": "user"}'
+
+ curl -sS -X POST "$URL/api/v1/admin/accounts/demo-ft/users" \
+ -H "X-API-Key: $ROOT_KEY" \
+ -H "Content-Type: application/json" \
+ -d '{"user_id": "bob", "role": "user"}'
+
+ curl -sS -X POST "$URL/api/v1/admin/accounts/demo-tf/users" \
+ -H "X-API-Key: $ROOT_KEY" \
+ -H "Content-Type: application/json" \
+ -d '{"user_id": "bob", "role": "user"}'
+
+ curl -sS -X POST "$URL/api/v1/admin/accounts/demo-tt/users" \
+ -H "X-API-Key: $ROOT_KEY" \
+ -H "Content-Type: application/json" \
+ -d '{"user_id": "bob", "role": "user"}'
+
+Examples:
+ python examples/multi_tenant/shared_session_role_id_http.py \
+ --url http://127.0.0.1:1933 \
+ --root-key <root-key>
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+import uuid
+from typing import Any, Dict, Optional
+
+import httpx
+
+OK = "[OK]"
+FAIL = "[FAIL]"
+UNSET = object()
+NAMESPACE_COMBINATIONS = [
+ ("ff", False, False),
+ ("ft", False, True),
+ ("tf", True, False),
+ ("tt", True, True),
+]
+
+
+def build_headers(
+ *,
+ api_key: str,
+ account: Optional[str] = None,
+ user: Optional[str] = None,
+ agent: Optional[str] = None,
+) -> Dict[str, str]:
+ headers = {
+ "X-API-Key": api_key,
+ "Content-Type": "application/json",
+ }
+ if account:
+ headers["X-OpenViking-Account"] = account
+ if user:
+ headers["X-OpenViking-User"] = user
+ if agent:
+ headers["X-OpenViking-Agent"] = agent
+ return headers
+
+
+def decode_json(response: httpx.Response) -> Any:
+ try:
+ return response.json()
+ except ValueError:
+ return response.text
+
+
+def print_response(label: str, response: httpx.Response) -> None:
+ payload = decode_json(response)
+ print(f"{label}: HTTP {response.status_code}")
+ if isinstance(payload, (dict, list)):
+ print(json.dumps(payload, indent=2, ensure_ascii=False))
+ else:
+ print(payload)
+ print()
+
+
+def expect_status(response: httpx.Response, expected: int, label: str) -> None:
+ if response.status_code != expected:
+ print_response(f"{FAIL} {label}", response)
+ raise SystemExit(1)
+ print(f"{OK} {label}: HTTP {response.status_code}")
+
+
+def create_session(
+ client: httpx.Client,
+ base_url: str,
+ headers: Dict[str, str],
+ session_id: Optional[str] = None,
+) -> str:
+ payload: Dict[str, Any] = {}
+ if session_id:
+ payload["session_id"] = session_id
+ response = client.post(f"{base_url}/api/v1/sessions", headers=headers, json=payload)
+ expect_status(response, 200, "create session")
+ return response.json()["result"]["session_id"]
+
+
+def create_account(
+ client: httpx.Client,
+ base_url: str,
+ *,
+ root_key: str,
+ account_id: str,
+ admin_user_id: str,
+ isolate_user_scope_by_agent: bool,
+ isolate_agent_scope_by_user: bool,
+) -> Dict[str, Any]:
+ response = client.post(
+ f"{base_url}/api/v1/admin/accounts",
+ headers=build_headers(api_key=root_key),
+ json={
+ "account_id": account_id,
+ "admin_user_id": admin_user_id,
+ "isolate_user_scope_by_agent": isolate_user_scope_by_agent,
+ "isolate_agent_scope_by_user": isolate_agent_scope_by_user,
+ },
+ )
+ expect_status(response, 200, f"create account {account_id}")
+ return response.json()["result"]
+
+
+def register_user(
+ client: httpx.Client,
+ base_url: str,
+ *,
+ api_key: str,
+ account_id: str,
+ user_id: str,
+ role: str = "user",
+) -> Dict[str, Any]:
+ response = client.post(
+ f"{base_url}/api/v1/admin/accounts/{account_id}/users",
+ headers=build_headers(api_key=api_key),
+ json={"user_id": user_id, "role": role},
+ )
+ expect_status(response, 200, f"register user {user_id} in {account_id}")
+ return response.json()["result"]
+
+
+def add_message(
+ client: httpx.Client,
+ base_url: str,
+ session_id: str,
+ headers: Dict[str, str],
+ *,
+ role: str,
+ content: str,
+ role_id: object = UNSET,
+) -> httpx.Response:
+ payload: Dict[str, Any] = {
+ "role": role,
+ "content": content,
+ }
+ if role_id is not UNSET:
+ payload["role_id"] = role_id
+ return client.post(
+ f"{base_url}/api/v1/sessions/{session_id}/messages",
+ headers=headers,
+ json=payload,
+ )
+
+
+def get_context(
+ client: httpx.Client,
+ base_url: str,
+ session_id: str,
+ headers: Dict[str, str],
+) -> httpx.Response:
+ return client.get(
+ f"{base_url}/api/v1/sessions/{session_id}/context",
+ headers=headers,
+ )
+
+
+def run_multi_user_flow(
+ client: httpx.Client,
+ *,
+ base_url: str,
+ account: str,
+ admin_key: str,
+ effective_user_a: str,
+ effective_agent_a: str,
+ effective_user_b: str,
+ effective_agent_b: str,
+ assistant_role_id: Optional[str],
+ session_id: Optional[str],
+) -> Dict[str, Any]:
+ admin_headers_a = build_headers(
+ api_key=admin_key,
+ account=account,
+ user=effective_user_a,
+ agent=effective_agent_a,
+ )
+ admin_headers_b = build_headers(
+ api_key=admin_key,
+ account=account,
+ user=effective_user_b,
+ agent=effective_agent_b,
+ )
+
+ session_id = create_session(
+ client,
+ base_url,
+ admin_headers_a,
+ session_id=session_id,
+ )
+ print(f"{OK} session_id = {session_id}")
+ print()
+
+ response = add_message(
+ client,
+ base_url,
+ session_id,
+ admin_headers_a,
+ role="user",
+ content=f"implicit actor from effective context: {effective_user_a}",
+ )
+ expect_status(response, 200, "admin implicit user role_id fill")
+
+ response = add_message(
+ client,
+ base_url,
+ session_id,
+ admin_headers_a,
+ role="user",
+ content=f"explicit actor set by admin: {effective_user_b}",
+ role_id=effective_user_b,
+ )
+ expect_status(response, 200, "admin explicit user role_id")
+
+ resolved_assistant_role_id = assistant_role_id or effective_agent_b
+ response = add_message(
+ client,
+ base_url,
+ session_id,
+ admin_headers_a,
+ role="assistant",
+ content=f"explicit assistant actor: {resolved_assistant_role_id}",
+ role_id=resolved_assistant_role_id,
+ )
+ expect_status(response, 200, "admin explicit assistant role_id")
+
+ context_from_other_user = get_context(
+ client,
+ base_url,
+ session_id,
+ admin_headers_b,
+ )
+ expect_status(context_from_other_user, 200, "shared session visible from other user view")
+ print_response("shared session context", context_from_other_user)
+ return {
+ "session_id": session_id,
+ "context": decode_json(context_from_other_user),
+ }
+
+
+def run_normal_user_flow(
+ client: httpx.Client,
+ *,
+ base_url: str,
+ user_key: str,
+ agent: str,
+ account: Optional[str],
+ user: Optional[str],
+ explicit_role_id: Optional[str],
+ expected_error_status: int,
+ session_id: Optional[str],
+) -> Dict[str, Any]:
+ user_headers = build_headers(
+ api_key=user_key,
+ account=account,
+ user=user,
+ agent=agent,
+ )
+
+ session_id = create_session(
+ client,
+ base_url,
+ user_headers,
+ session_id=session_id,
+ )
+ print(f"{OK} session_id = {session_id}")
+ print()
+
+ response = add_message(
+ client,
+ base_url,
+ session_id,
+ user_headers,
+ role="user",
+ content="implicit actor from user key context",
+ )
+ expect_status(response, 200, "user implicit role_id fill")
+
+ response = add_message(
+ client,
+ base_url,
+ session_id,
+ user_headers,
+ role="assistant",
+ content=f"implicit assistant actor from agent context: {agent}",
+ )
+ expect_status(response, 200, "user implicit assistant role_id fill")
+
+ resolved_explicit_role_id = explicit_role_id or "explicit-user"
+ response = add_message(
+ client,
+ base_url,
+ session_id,
+ user_headers,
+ role="user",
+ content=f"this should fail with explicit role_id: {resolved_explicit_role_id}",
+ role_id=resolved_explicit_role_id,
+ )
+ if response.status_code == expected_error_status:
+ print_response(
+ f"{OK} user explicit role_id rejected as expected",
+ response,
+ )
+ else:
+ print_response(
+ f"{FAIL} user explicit role_id should have been rejected",
+ response,
+ )
+ raise SystemExit(1)
+
+ context_response = get_context(client, base_url, session_id, user_headers)
+ expect_status(context_response, 200, "load session context")
+ print_response("normal user session context", context_response)
+ return {
+ "session_id": session_id,
+ "context": decode_json(context_response),
+ }
+
+
+def run_setup_and_run(args: argparse.Namespace) -> Dict[str, Any]:
+ base_url = args.url.rstrip("/")
+ run_id = args.run_id or uuid.uuid4().hex[:8]
+ name_prefix = args.name_prefix or f"demo-auto-{run_id}"
+ summary: Dict[str, Any] = {
+ "run_id": run_id,
+ "name_prefix": name_prefix,
+ "accounts": [],
+ }
+
+ with httpx.Client(timeout=args.timeout) as client:
+ health = client.get(f"{base_url}/health")
+ expect_status(health, 200, "health check")
+
+ for (
+ suffix,
+ isolate_user_scope_by_agent,
+ isolate_agent_scope_by_user,
+ ) in NAMESPACE_COMBINATIONS:
+ account_id = f"{name_prefix}-{suffix}"
+ print(f"== Account {account_id} ==")
+ account_result = create_account(
+ client,
+ base_url,
+ root_key=args.root_key,
+ account_id=account_id,
+ admin_user_id=args.admin_user,
+ isolate_user_scope_by_agent=isolate_user_scope_by_agent,
+ isolate_agent_scope_by_user=isolate_agent_scope_by_user,
+ )
+ user_result = register_user(
+ client,
+ base_url,
+ api_key=args.root_key,
+ account_id=account_id,
+ user_id=args.regular_user,
+ role="user",
+ )
+
+ multi_session_id = f"{account_id}-multi-{run_id}"
+ normal_session_id = f"{account_id}-normal-{run_id}"
+
+ print(f"-- multi-user scenario for {account_id} --")
+ multi_result = run_multi_user_flow(
+ client,
+ base_url=base_url,
+ account=account_id,
+ admin_key=account_result["user_key"],
+ effective_user_a=args.admin_user,
+ effective_agent_a=args.effective_agent_a,
+ effective_user_b=args.regular_user,
+ effective_agent_b=args.effective_agent_b,
+ assistant_role_id=args.assistant_role_id,
+ session_id=multi_session_id,
+ )
+
+ print(f"-- normal-user scenario for {account_id} --")
+ normal_result = run_normal_user_flow(
+ client,
+ base_url=base_url,
+ user_key=user_result["user_key"],
+ agent=args.normal_user_agent,
+ account=None,
+ user=None,
+ explicit_role_id=args.explicit_role_id,
+ expected_error_status=args.expected_error_status,
+ session_id=normal_session_id,
+ )
+
+ summary["accounts"].append(
+ {
+ "account_id": account_id,
+ "namespace_policy": {
+ "isolate_user_scope_by_agent": isolate_user_scope_by_agent,
+ "isolate_agent_scope_by_user": isolate_agent_scope_by_user,
+ },
+ "admin_user_id": args.admin_user,
+ "admin_key": account_result["user_key"],
+ "regular_user_id": args.regular_user,
+ "regular_user_key": user_result["user_key"],
+ "multi_user": multi_result,
+ "normal_user": normal_result,
+ }
+ )
+ print()
+
+ print("== Summary ==")
+ print(json.dumps(summary, indent=2, ensure_ascii=False))
+ return summary
+
+
+def build_parser() -> argparse.ArgumentParser:
+ parser = argparse.ArgumentParser(description="Shared session + role_id HTTP demo")
+ parser.add_argument(
+ "--url",
+ default="http://127.0.0.1:1933",
+ help="OpenViking server base URL",
+ )
+ parser.add_argument(
+ "--timeout",
+ type=float,
+ default=30.0,
+ help="HTTP timeout in seconds",
+ )
+ parser.add_argument("--root-key", required=True, help="ROOT API key")
+ parser.add_argument(
+ "--name-prefix",
+ default=None,
+ help="Account prefix. Defaults to demo-auto-<run_id>",
+ )
+ parser.add_argument(
+ "--run-id",
+ default=None,
+ help="Optional fixed run id used in account/session naming",
+ )
+ parser.add_argument(
+ "--admin-user",
+ default="alice",
+ help="Admin user created in every account",
+ )
+ parser.add_argument(
+ "--regular-user",
+ default="bob",
+ help="Regular USER created in every account",
+ )
+ parser.add_argument(
+ "--effective-agent-a",
+ default="agent-a",
+ help="Agent used for ADMIN effective context A",
+ )
+ parser.add_argument(
+ "--effective-agent-b",
+ default="agent-b",
+ help="Agent used for ADMIN effective context B",
+ )
+ parser.add_argument(
+ "--normal-user-agent",
+ default="agent-a",
+ help="Agent used for USER scenario",
+ )
+ parser.add_argument(
+ "--assistant-role-id",
+ default=None,
+ help="Optional explicit assistant role_id for the ADMIN scenario",
+ )
+ parser.add_argument(
+ "--explicit-role-id",
+ default=None,
+ help="Optional explicit role_id used for the USER negative test",
+ )
+ parser.add_argument(
+ "--expected-error-status",
+ type=int,
+ default=400,
+ help="Expected HTTP status when USER explicitly sends role_id",
+ )
+
+ return parser
+
+
+def main() -> int:
+ parser = build_parser()
+ args = parser.parse_args()
+ try:
+ run_setup_and_run(args)
+ except httpx.HTTPError as exc:
+ print(f"{FAIL} HTTP error: {exc}")
+ return 1
+ return 0
+
+
+if __name__ == "__main__":
+ sys.exit(main())
diff --git a/openviking/async_client.py b/openviking/async_client.py
index ab56d520d..0c509d388 100644
--- a/openviking/async_client.py
+++ b/openviking/async_client.py
@@ -172,6 +172,7 @@ class AsyncOpenViking:
content: str | None = None,
parts: list[dict] | None = None,
created_at: str | None = None,
+ role_id: str | None = None,
) -> Dict[str, Any]:
"""Add a message to a session.
@@ -181,12 +182,18 @@ class AsyncOpenViking:
content: Text content (simple mode)
parts: Parts array (full Part support: TextPart, ContextPart, ToolPart)
created_at: Message creation time (ISO format string)
+ role_id: Optional explicit actor identity. Omit to let the client/server derive it.
If both content and parts are provided, parts takes precedence.
"""
await self._ensure_initialized()
return await self._client.add_message(
- session_id=session_id, role=role, content=content, parts=parts, created_at=created_at
+ session_id=session_id,
+ role=role,
+ content=content,
+ parts=parts,
+ created_at=created_at,
+ role_id=role_id,
)
async def commit_session(
diff --git a/openviking/client/local.py b/openviking/client/local.py
index 21735e990..dbb38164c 100644
--- a/openviking/client/local.py
+++ b/openviking/client/local.py
@@ -455,6 +455,7 @@ class LocalClient(BaseClient):
content: Optional[str] = None,
parts: Optional[List[Dict[str, Any]]] = None,
created_at: Optional[str] = None,
+ role_id: Optional[str] = None,
) -> Dict[str, Any]:
"""Add a message to a session.
@@ -464,13 +465,13 @@ class LocalClient(BaseClient):
content: Text content (simple mode, backward compatible)
parts: Parts array (full Part support mode)
created_at: Message creation time (ISO format string)
+ role_id: Optional explicit actor identity. Omit to derive it from the local context.
If both content and parts are provided, parts takes precedence.
"""
from openviking.message.part import Part, TextPart, part_from_dict
- session = self._service.sessions.session(self._ctx, session_id)
- await session.load()
+ session = await self._service.sessions.get(session_id, self._ctx, auto_create=True)
message_parts: list[Part]
if parts is not None:
@@ -480,8 +481,12 @@ class LocalClient(BaseClient):
else:
raise ValueError("Either content or parts must be provided")
- # created_at 直接传递给 session (毫秒时间戳)
- session.add_message(role, message_parts, created_at=created_at)
+ if role_id is None and role == "user":
+ role_id = self._ctx.user.user_id
+ elif role_id is None and role == "assistant":
+ role_id = self._ctx.user.agent_id
+
+ session.add_message(role, message_parts, role_id=role_id, created_at=created_at)
return {
"session_id": session_id,
"message_count": len(session.messages),
@@ -520,11 +525,12 @@ class LocalClient(BaseClient):
Returns:
Session object if exists, None otherwise.
"""
-
+
session = self._service.sessions.session(self._ctx, session_id)
if not run_async(session.exists()):
if must_exist and session_id:
from openviking_cli.exceptions import NotFoundError
+
raise NotFoundError(session_id, "session")
else:
run_async(session.ensure_exists())
diff --git a/openviking/client/session.py b/openviking/client/session.py
index 27b6b33b6..1c6bd2f24 100644
--- a/openviking/client/session.py
+++ b/openviking/client/session.py
@@ -41,6 +41,7 @@ class Session:
content: Optional[str] = None,
parts: Optional[List[Part]] = None,
created_at: Optional[str] = None,
+ role_id: Optional[str] = None,
) -> Dict[str, Any]:
"""Add a message to the session.
@@ -49,6 +50,7 @@ class Session:
content: Text content (simple mode)
parts: Parts list (TextPart, ContextPart, ToolPart)
created_at: Message creation time (ISO format string). If not provided, current time is used.
+ role_id: Optional explicit actor identity. Omit to let the server derive it.
If both content and parts are provided, parts takes precedence.
@@ -58,10 +60,18 @@ class Session:
if parts is not None:
parts_dicts = [asdict(p) for p in parts]
return await self._client.add_message(
- self.session_id, role, parts=parts_dicts, created_at=created_at
+ self.session_id,
+ role,
+ parts=parts_dicts,
+ created_at=created_at,
+ role_id=role_id,
)
return await self._client.add_message(
- self.session_id, role, content=content, created_at=created_at
+ self.session_id,
+ role,
+ content=content,
+ created_at=created_at,
+ role_id=role_id,
)
async def commit(self, telemetry: TelemetryRequest = False) -> Dict[str, Any]:
diff --git a/openviking/console/static/app.js b/openviking/console/static/app.js
index ef919e5fb..1f06840e2 100644
--- a/openviking/console/static/app.js
+++ b/openviking/console/static/app.js
@@ -2337,9 +2337,10 @@ function bindAddMemory() {
}
for (const msg of messages) {
+ const payload = { ...msg };
await callConsole(`/ov/sessions/${sessionId}/messages`, {
method: "POST",
- body: JSON.stringify(msg),
+ body: JSON.stringify(payload),
});
}
diff --git a/openviking/core/__init__.py b/openviking/core/__init__.py
index 1c33e6c0a..1baea54b3 100644
--- a/openviking/core/__init__.py
+++ b/openviking/core/__init__.py
@@ -2,14 +2,35 @@
# SPDX-License-Identifier: AGPL-3.0
"""Core context abstractions for OpenViking."""
-from openviking.core.building_tree import BuildingTree
-from openviking.core.context import Context, ResourceContentType
-from openviking.core.directories import (
- PRESET_DIRECTORIES,
- DirectoryDefinition,
- DirectoryInitializer,
-)
-from openviking.core.skill_loader import SkillLoader
+from importlib import import_module
+from typing import Any
+
+_EXPORTS = {
+ "BuildingTree": ("openviking.core.building_tree", "BuildingTree"),
+ "Context": ("openviking.core.context", "Context"),
+ "ContextType": ("openviking.core.context", "ContextType"),
+ "ResourceContentType": ("openviking.core.context", "ResourceContentType"),
+ "SkillLoader": ("openviking.core.skill_loader", "SkillLoader"),
+ "DirectoryDefinition": ("openviking.core.directories", "DirectoryDefinition"),
+ "PRESET_DIRECTORIES": ("openviking.core.directories", "PRESET_DIRECTORIES"),
+ "DirectoryInitializer": ("openviking.core.directories", "DirectoryInitializer"),
+}
+
+
+def __getattr__(name: str) -> Any:
+ try:
+ module_name, attr_name = _EXPORTS[name]
+ except KeyError as exc:
+ raise AttributeError(f"module {__name__!r} has no attribute {name!r}") from exc
+
+ value = getattr(import_module(module_name), attr_name)
+ globals()[name] = value
+ return value
+
+
+def __dir__() -> list[str]:
+ return sorted(list(globals().keys()) + list(__all__))
+
__all__ = [
# Context
diff --git a/openviking/core/context.py b/openviking/core/context.py
index 55bce1c47..612437bde 100644
--- a/openviking/core/context.py
+++ b/openviking/core/context.py
@@ -7,6 +7,7 @@ from enum import Enum
from typing import Any, Dict, List, Optional
from uuid import uuid4
+from openviking.core.namespace import owner_fields_for_uri
from openviking.utils.time_utils import format_iso8601, parse_iso_datetime
from openviking_cli.session.user_id import UserIdentifier
from openviking_cli.utils.uri import VikingURI
@@ -71,6 +72,8 @@ class Context:
session_id: Optional[str] = None,
user: Optional[UserIdentifier] = None,
account_id: Optional[str] = None,
+ owner_user_id: Optional[str] = None,
+ owner_agent_id: Optional[str] = None,
owner_space: Optional[str] = None,
id: Optional[str] = None,
):
@@ -97,6 +100,17 @@ class Context:
self.session_id = session_id
self.user = user
self.account_id = account_id or (user.account_id if user else "default")
+ owner_fields = owner_fields_for_uri(
+ uri,
+ user=user,
+ account_id=self.account_id,
+ )
+ self.owner_user_id = (
+ owner_user_id if owner_user_id is not None else owner_fields["owner_user_id"]
+ )
+ self.owner_agent_id = (
+ owner_agent_id if owner_agent_id is not None else owner_fields["owner_agent_id"]
+ )
self.owner_space = owner_space or self._derive_owner_space(user)
self.vector: Optional[List[float]] = None
self.vectorize = Vectorize(abstract)
@@ -106,9 +120,9 @@ class Context:
if not user:
return ""
if self.uri.startswith("viking://agent/"):
- return user.agent_space_name()
+ return user.agent_id
if self.uri.startswith("viking://user/") or self.uri.startswith("viking://session/"):
- return user.user_space_name()
+ return user.user_id
return ""
def _derive_context_type(self) -> str:
@@ -175,6 +189,8 @@ class Context:
"related_uri": self.related_uri,
"session_id": self.session_id,
"account_id": self.account_id,
+ "owner_user_id": self.owner_user_id,
+ "owner_agent_id": self.owner_agent_id,
"owner_space": self.owner_space,
}
if self.level is not None:
@@ -235,6 +251,8 @@ class Context:
session_id=data.get("session_id"),
user=user_obj,
account_id=data.get("account_id"),
+ owner_user_id=data.get("owner_user_id"),
+ owner_agent_id=data.get("owner_agent_id"),
owner_space=data.get("owner_space"),
)
obj.id = data.get("id", obj.id)
diff --git a/openviking/core/directories.py b/openviking/core/directories.py
index e0dedb0f0..3621c553c 100644
--- a/openviking/core/directories.py
+++ b/openviking/core/directories.py
@@ -11,11 +11,18 @@ from dataclasses import dataclass, field
from typing import TYPE_CHECKING, Dict, List, Optional
from openviking.core.context import Context, ContextType, Vectorize
+from openviking.core.namespace import (
+ agent_space_fragment,
+ canonical_agent_root,
+ canonical_user_root,
+ user_space_fragment,
+)
from openviking.server.identity import RequestContext
from openviking.storage.queuefs.embedding_msg_converter import EmbeddingMsgConverter
if TYPE_CHECKING:
from openviking.storage import VikingDBManager
+ from openviking.storage.viking_fs import VikingFS
@dataclass
@@ -143,8 +150,17 @@ class DirectoryInitializer:
def __init__(
self,
vikingdb: "VikingDBManager",
+ viking_fs: Optional["VikingFS"] = None,
):
self.vikingdb = vikingdb
+ self._viking_fs = viking_fs
+
+ def _get_viking_fs(self) -> "VikingFS":
+ if self._viking_fs is not None:
+ return self._viking_fs
+ from openviking.storage.viking_fs import get_viking_fs
+
+ return get_viking_fs()
async def initialize_account_directories(self, ctx: RequestContext) -> int:
"""Initialize account-shared scope roots."""
@@ -172,11 +188,16 @@ class DirectoryInitializer:
"""Initialize user-space tree lazily for the current user."""
if "user" not in PRESET_DIRECTORIES:
return 0
- user_space_root = f"viking://user/{ctx.user.user_space_name()}"
+ user_space_root = canonical_user_root(ctx)
user_tree = PRESET_DIRECTORIES["user"]
+ parent_uri = "viking://user"
+ if ctx.namespace_policy.isolate_user_scope_by_agent:
+ container_uri = f"viking://user/{ctx.user.user_id}"
+ await self._ensure_container_directory(container_uri, parent_uri=parent_uri, ctx=ctx)
+ parent_uri = container_uri
created = await self._ensure_directory(
uri=user_space_root,
- parent_uri="viking://user",
+ parent_uri=parent_uri,
defn=user_tree,
scope="user",
ctx=ctx,
@@ -191,11 +212,16 @@ class DirectoryInitializer:
"""Initialize agent-space tree lazily for the current user+agent."""
if "agent" not in PRESET_DIRECTORIES:
return 0
- agent_space_root = f"viking://agent/{ctx.user.agent_space_name()}"
+ agent_space_root = canonical_agent_root(ctx)
agent_tree = PRESET_DIRECTORIES["agent"]
+ parent_uri = "viking://agent"
+ if ctx.namespace_policy.isolate_agent_scope_by_user:
+ container_uri = f"viking://agent/{ctx.user.agent_id}"
+ await self._ensure_container_directory(container_uri, parent_uri=parent_uri, ctx=ctx)
+ parent_uri = container_uri
created = await self._ensure_directory(
uri=agent_space_root,
- parent_uri="viking://agent",
+ parent_uri=parent_uri,
defn=agent_tree,
scope="agent",
ctx=ctx,
@@ -207,6 +233,18 @@ class DirectoryInitializer:
return count
+ async def _ensure_container_directory(
+ self,
+ uri: str,
+ parent_uri: Optional[str],
+ ctx: RequestContext,
+ ) -> None:
+ """Ensure an intermediate namespace container exists without seeding vectors."""
+ try:
+ await self._get_viking_fs().mkdir(uri, exist_ok=True, ctx=ctx)
+ except Exception:
+ pass
+
async def _ensure_directory(
self,
uri: str,
@@ -282,17 +320,15 @@ class DirectoryInitializer:
@staticmethod
def _owner_space_for_scope(scope: str, ctx: RequestContext) -> str:
if scope in {"user", "session"}:
- return ctx.user.user_space_name()
+ return user_space_fragment(ctx)
if scope == "agent":
- return ctx.user.agent_space_name()
+ return agent_space_fragment(ctx)
return ""
async def _check_agfs_files_exist(self, uri: str, ctx: RequestContext) -> bool:
"""Check if L0/L1 files exist in AGFS."""
- from openviking.storage.viking_fs import get_viking_fs
-
try:
- viking_fs = get_viking_fs()
+ viking_fs = self._get_viking_fs()
await viking_fs.abstract(uri, ctx=ctx)
return True
except Exception:
@@ -330,9 +366,7 @@ class DirectoryInitializer:
self, uri: str, abstract: str, overview: str, ctx: RequestContext
) -> None:
"""Create L0/L1 file structure for directory in AGFS."""
- from openviking.storage.viking_fs import get_viking_fs
-
- await get_viking_fs().write_context(
+ await self._get_viking_fs().write_context(
uri=uri,
abstract=abstract,
overview=overview,
diff --git a/openviking/core/namespace.py b/openviking/core/namespace.py
new file mode 100644
index 000000000..213099817
--- /dev/null
+++ b/openviking/core/namespace.py
@@ -0,0 +1,328 @@
+"""Namespace policy helpers for account/user/agent/session URIs."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Optional
+
+from openviking.server.identity import AccountNamespacePolicy, RequestContext
+from openviking_cli.utils.uri import VikingURI
+
+_USER_SHORTHAND_SEGMENTS = {"memories", "profile.md", ".abstract.md", ".overview.md"}
+_AGENT_SHORTHAND_SEGMENTS = {
+ "memories",
+ "skills",
+ "instructions",
+ "workspaces",
+ ".abstract.md",
+ ".overview.md",
+}
+
+
+class NamespaceShapeError(ValueError):
+ """Raised when a URI does not match the active namespace policy shape."""
+
+
+@dataclass(frozen=True)
+class ResolvedNamespace:
+ """Canonicalized namespace information for a URI."""
+
+ uri: str
+ scope: str
+ owner_user_id: Optional[str] = None
+ owner_agent_id: Optional[str] = None
+ is_container: bool = False
+
+
+def _uri_parts(uri: str) -> list[str]:
+ normalized = VikingURI.normalize(uri).rstrip("/")
+ if normalized == "viking:":
+ normalized = "viking://"
+ if normalized == "viking://":
+ return []
+ return [part for part in normalized[len("viking://") :].split("/") if part]
+
+
+def canonical_user_root(ctx: RequestContext) -> str:
+ return f"viking://user/{user_space_fragment(ctx)}"
+
+
+def user_space_fragment(ctx: RequestContext) -> str:
+ if ctx.namespace_policy.isolate_user_scope_by_agent:
+ return f"{ctx.user.user_id}/agent/{ctx.user.agent_id}"
+ return ctx.user.user_id
+
+
+def canonical_agent_root(ctx: RequestContext) -> str:
+ return f"viking://agent/{agent_space_fragment(ctx)}"
+
+
+def agent_space_fragment(ctx: RequestContext) -> str:
+ if ctx.namespace_policy.isolate_agent_scope_by_user:
+ return f"{ctx.user.agent_id}/user/{ctx.user.user_id}"
+ return ctx.user.agent_id
+
+
+def canonical_session_uri(session_id: Optional[str] = None) -> str:
+ if not session_id:
+ return "viking://session"
+ return f"viking://session/{session_id}"
+
+
+def visible_roots(ctx: RequestContext) -> list[str]:
+ return [
+ "viking://resources",
+ "viking://session",
+ canonical_user_root(ctx),
+ canonical_agent_root(ctx),
+ ]
+
+
+def resolve_uri(
+ uri: str,
+ ctx: Optional[RequestContext] = None,
+ *,
+ require_canonical: bool = False,
+) -> ResolvedNamespace:
+ """Resolve a URI into a canonical URI and owner tuple."""
+
+ parts = _uri_parts(uri)
+ if not parts:
+ return ResolvedNamespace(uri="viking://", scope="", is_container=True)
+
+ scope = parts[0]
+ if scope == "user":
+ return _resolve_user_uri(parts, ctx=ctx, require_canonical=require_canonical)
+ if scope == "agent":
+ return _resolve_agent_uri(parts, ctx=ctx, require_canonical=require_canonical)
+ if scope == "session":
+ return _resolve_session_uri(parts)
+ if scope in {"resources", "temp", "queue"}:
+ return ResolvedNamespace(uri=VikingURI.normalize(uri).rstrip("/"), scope=scope)
+ return ResolvedNamespace(uri=VikingURI.normalize(uri).rstrip("/"), scope=scope)
+
+
+def canonicalize_uri(uri: str, ctx: Optional[RequestContext] = None) -> str:
+ return resolve_uri(uri, ctx=ctx).uri
+
+
+def is_accessible(uri: str, ctx: RequestContext) -> bool:
+ if getattr(ctx.role, "value", ctx.role) == "root":
+ return True
+
+ try:
+ target = resolve_uri(uri, ctx=ctx)
+ except NamespaceShapeError:
+ return False
+
+ if target.scope in {"", "resources", "temp", "queue", "session"}:
+ return True
+ if target.scope == "user":
+ if target.owner_user_id and target.owner_user_id != ctx.user.user_id:
+ return False
+ if (
+ ctx.namespace_policy.isolate_user_scope_by_agent
+ and target.owner_agent_id is not None
+ and target.owner_agent_id != ctx.user.agent_id
+ ):
+ return False
+ return True
+ if target.scope == "agent":
+ if target.owner_agent_id and target.owner_agent_id != ctx.user.agent_id:
+ return False
+ if (
+ ctx.namespace_policy.isolate_agent_scope_by_user
+ and target.owner_user_id is not None
+ and target.owner_user_id != ctx.user.user_id
+ ):
+ return False
+ return True
+ return True
+
+
+def owner_fields_for_uri(
+ uri: str,
+ ctx: Optional[RequestContext] = None,
+ *,
+ user=None,
+ account_id: Optional[str] = None,
+ policy: Optional[AccountNamespacePolicy] = None,
+) -> dict:
+ resolved_ctx = ctx
+ if resolved_ctx is None and user is not None:
+ from openviking.server.identity import Role
+
+ resolved_ctx = RequestContext(
+ user=user,
+ role=Role.ROOT,
+ namespace_policy=policy or AccountNamespacePolicy(),
+ )
+ if resolved_ctx is None and account_id:
+ from openviking.server.identity import Role
+ from openviking_cli.session.user_id import UserIdentifier
+
+ resolved_ctx = RequestContext(
+ user=UserIdentifier(account_id, "default", "default"),
+ role=Role.ROOT,
+ namespace_policy=policy or AccountNamespacePolicy(),
+ )
+
+ try:
+ resolved = resolve_uri(uri, ctx=resolved_ctx)
+ except NamespaceShapeError:
+ return {
+ "uri": VikingURI.normalize(uri).rstrip("/"),
+ "owner_user_id": None,
+ "owner_agent_id": None,
+ }
+ return {
+ "uri": resolved.uri,
+ "owner_user_id": resolved.owner_user_id,
+ "owner_agent_id": resolved.owner_agent_id,
+ }
+
+
+def _resolve_user_uri(
+ parts: list[str],
+ ctx: Optional[RequestContext],
+ *,
+ require_canonical: bool,
+) -> ResolvedNamespace:
+ normalized = "viking://" + "/".join(parts)
+ if len(parts) == 1:
+ return ResolvedNamespace(uri="viking://user", scope="user", is_container=True)
+
+ second = parts[1]
+ if second in _USER_SHORTHAND_SEGMENTS:
+ if require_canonical:
+ raise NamespaceShapeError(f"Shorthand user URI is not allowed here: {normalized}")
+ if ctx is None:
+ raise NamespaceShapeError(f"User shorthand URI requires request context: {normalized}")
+ suffix = parts[1:]
+ return resolve_uri(
+ "/".join([canonical_user_root(ctx)[len("viking://") :], *suffix]), ctx=ctx
+ )
+
+ user_id = second
+ policy = _require_policy(ctx)
+ if len(parts) == 2:
+ if policy.isolate_user_scope_by_agent:
+ return ResolvedNamespace(
+ uri=f"viking://user/{user_id}",
+ scope="user",
+ owner_user_id=user_id,
+ is_container=True,
+ )
+ return ResolvedNamespace(
+ uri=f"viking://user/{user_id}",
+ scope="user",
+ owner_user_id=user_id,
+ )
+
+ if policy.isolate_user_scope_by_agent:
+ if len(parts) < 4 or parts[2] != "agent":
+ raise NamespaceShapeError(
+ f"User URI must include /agent/{{agent_id}} under current policy: {normalized}"
+ )
+ agent_id = parts[3]
+ suffix = parts[4:]
+ canonical = f"viking://user/{user_id}/agent/{agent_id}"
+ if suffix:
+ canonical = f"{canonical}/{'/'.join(suffix)}"
+ return ResolvedNamespace(
+ uri=canonical,
+ scope="user",
+ owner_user_id=user_id,
+ owner_agent_id=agent_id,
+ )
+
+ suffix = parts[2:]
+ canonical = f"viking://user/{user_id}"
+ if suffix:
+ canonical = f"{canonical}/{'/'.join(suffix)}"
+ return ResolvedNamespace(
+ uri=canonical,
+ scope="user",
+ owner_user_id=user_id,
+ )
+
+
+def _resolve_agent_uri(
+ parts: list[str],
+ ctx: Optional[RequestContext],
+ *,
+ require_canonical: bool,
+) -> ResolvedNamespace:
+ normalized = "viking://" + "/".join(parts)
+ if len(parts) == 1:
+ return ResolvedNamespace(uri="viking://agent", scope="agent", is_container=True)
+
+ second = parts[1]
+ if second in _AGENT_SHORTHAND_SEGMENTS:
+ if require_canonical:
+ raise NamespaceShapeError(f"Shorthand agent URI is not allowed here: {normalized}")
+ if ctx is None:
+ raise NamespaceShapeError(f"Agent shorthand URI requires request context: {normalized}")
+ suffix = parts[1:]
+ return resolve_uri(
+ "/".join([canonical_agent_root(ctx)[len("viking://") :], *suffix]), ctx=ctx
+ )
+
+ agent_id = second
+ policy = _require_policy(ctx)
+ if len(parts) == 2:
+ if policy.isolate_agent_scope_by_user:
+ return ResolvedNamespace(
+ uri=f"viking://agent/{agent_id}",
+ scope="agent",
+ owner_agent_id=agent_id,
+ is_container=True,
+ )
+ return ResolvedNamespace(
+ uri=f"viking://agent/{agent_id}",
+ scope="agent",
+ owner_agent_id=agent_id,
+ )
+
+ if policy.isolate_agent_scope_by_user:
+ if len(parts) < 4 or parts[2] != "user":
+ raise NamespaceShapeError(
+ f"Agent URI must include /user/{{user_id}} under current policy: {normalized}"
+ )
+ user_id = parts[3]
+ suffix = parts[4:]
+ canonical = f"viking://agent/{agent_id}/user/{user_id}"
+ if suffix:
+ canonical = f"{canonical}/{'/'.join(suffix)}"
+ return ResolvedNamespace(
+ uri=canonical,
+ scope="agent",
+ owner_user_id=user_id,
+ owner_agent_id=agent_id,
+ )
+
+ suffix = parts[2:]
+ canonical = f"viking://agent/{agent_id}"
+ if suffix:
+ canonical = f"{canonical}/{'/'.join(suffix)}"
+ return ResolvedNamespace(
+ uri=canonical,
+ scope="agent",
+ owner_agent_id=agent_id,
+ )
+
+
+def _resolve_session_uri(parts: list[str]) -> ResolvedNamespace:
+ if len(parts) == 1:
+ return ResolvedNamespace(uri="viking://session", scope="session", is_container=True)
+ session_id = parts[1]
+ canonical = f"viking://session/{session_id}"
+ if len(parts) > 2:
+ canonical = f"{canonical}/{'/'.join(parts[2:])}"
+ return ResolvedNamespace(uri=canonical, scope="session")
+
+
+def _require_policy(ctx: Optional[RequestContext]) -> AccountNamespacePolicy:
+ if ctx is None:
+ return AccountNamespacePolicy()
+ return ctx.namespace_policy
diff --git a/openviking/message/message.py b/openviking/message/message.py
index b14867f52..c0cba66f6 100644
--- a/openviking/message/message.py
+++ b/openviking/message/message.py
@@ -20,6 +20,7 @@ class Message:
id: str
role: Literal["user", "assistant"]
parts: List[Part]
+ role_id: Optional[str] = None
created_at: str = None
@property
@@ -73,6 +74,7 @@ class Message:
return {
"id": self.id,
"role": self.role,
+ "role_id": self.role_id,
"parts": [self._part_to_dict(p) for p in self.parts],
"created_at": created_at_val,
}
@@ -151,11 +153,17 @@ class Message:
id=data["id"],
role=data["role"],
parts=parts,
+ role_id=data.get("role_id"),
created_at=data.get("created_at"),
)
@classmethod
- def create_user(cls, content: str, msg_id: str = None) -> "Message":
+ def create_user(
+ cls,
+ content: str,
+ msg_id: str = None,
+ role_id: Optional[str] = None,
+ ) -> "Message":
"""Create user message."""
from uuid import uuid4
@@ -163,6 +171,7 @@ class Message:
id=msg_id or f"msg_{uuid4().hex}",
role="user",
parts=[TextPart(text=content)],
+ role_id=role_id,
created_at=datetime.now(timezone.utc).isoformat(),
)
@@ -173,6 +182,7 @@ class Message:
context_refs: List[dict] = None,
tool_calls: List[dict] = None,
msg_id: str = None,
+ role_id: Optional[str] = None,
) -> "Message":
"""Create assistant message."""
from uuid import uuid4
@@ -206,6 +216,7 @@ class Message:
id=msg_id or f"msg_{uuid4().hex}",
role="assistant",
parts=parts,
+ role_id=role_id,
created_at=datetime.now(timezone.utc).isoformat(),
)
diff --git a/openviking/message/part.py b/openviking/message/part.py
index 862ccd8a2..8eeebaea3 100644
--- a/openviking/message/part.py
+++ b/openviking/message/part.py
@@ -41,7 +41,7 @@ class ToolPart:
tool_id: str = ""
tool_name: str = ""
tool_uri: str = "" # viking://session/{user_space_name}/{session_id}/tools/{tool_id}
- skill_uri: str = "" # viking://agent/{agent_space_name}/skills/{skill_name}
+ skill_uri: str = "" # viking://agent/{agent_id}/skills/{skill_name} or .../user/{user_id}/skills/{skill_name}
tool_input: Optional[dict] = None
tool_output: str = ""
tool_status: str = "pending" # pending | running | completed | error
diff --git a/openviking/retrieve/hierarchical_retriever.py b/openviking/retrieve/hierarchical_retriever.py
index 5c7419200..338caf8ec 100644
--- a/openviking/retrieve/hierarchical_retriever.py
+++ b/openviking/retrieve/hierarchical_retriever.py
@@ -14,6 +14,7 @@ import time
from datetime import datetime
from typing import Any, Dict, List, Optional, Tuple
+from openviking.core.namespace import canonical_agent_root, canonical_user_root
from openviking.models.embedder.base import EmbedResult, embed_compat
from openviking.models.rerank import RerankClient
from openviking.retrieve.memory_lifecycle import hotness_score
@@ -596,22 +597,22 @@ class HierarchicalRetriever:
if not ctx or ctx.role == Role.ROOT:
return []
- user_space = ctx.user.user_space_name()
- agent_space = ctx.user.agent_space_name()
+ user_root = canonical_user_root(ctx)
+ agent_root = canonical_agent_root(ctx)
if context_type is None:
return [
- f"viking://user/{user_space}/memories",
- f"viking://agent/{agent_space}/memories",
+ f"{user_root}/memories",
+ f"{agent_root}/memories",
"viking://resources",
- f"viking://agent/{agent_space}/skills",
+ f"{agent_root}/skills",
]
elif context_type == ContextType.MEMORY:
return [
- f"viking://user/{user_space}/memories",
- f"viking://agent/{agent_space}/memories",
+ f"{user_root}/memories",
+ f"{agent_root}/memories",
]
elif context_type == ContextType.RESOURCE:
return ["viking://resources"]
elif context_type == ContextType.SKILL:
- return [f"viking://agent/{agent_space}/skills"]
+ return [f"{agent_root}/skills"]
return []
diff --git a/openviking/server/api_keys.py b/openviking/server/api_keys.py
index e252454af..493d6c0ac 100644
--- a/openviking/server/api_keys.py
+++ b/openviking/server/api_keys.py
@@ -12,7 +12,7 @@ from typing import Dict, Optional
from argon2 import PasswordHasher
from argon2.exceptions import VerifyMismatchError
-from openviking.server.identity import ResolvedIdentity, Role
+from openviking.server.identity import AccountNamespacePolicy, ResolvedIdentity, Role
from openviking.storage.viking_fs import VikingFS
from openviking_cli.exceptions import (
AlreadyExistsError,
@@ -25,6 +25,7 @@ logger = get_logger(__name__)
ACCOUNTS_PATH = "/local/_system/accounts.json"
USERS_PATH_TEMPLATE = "/local/{account_id}/_system/users.json"
+SETTINGS_PATH_TEMPLATE = "/local/{account_id}/_system/setting.json"
# Argon2id parameters
@@ -51,6 +52,7 @@ class AccountInfo:
created_at: str
users: Dict[str, dict] = field(default_factory=dict)
+ namespace_policy: AccountNamespacePolicy = field(default_factory=AccountNamespacePolicy)
class APIKeyManager:
@@ -64,7 +66,12 @@ class APIKeyManager:
Uses Argon2id for secure API key hashing.
"""
- def __init__(self, root_key: str, viking_fs: VikingFS, encryption_enabled: bool = False):
+ def __init__(
+ self,
+ root_key: str,
+ viking_fs: VikingFS,
+ encryption_enabled: bool = False,
+ ):
"""Initialize APIKeyManager.
Args:
@@ -82,6 +89,7 @@ class APIKeyManager:
async def load(self) -> None:
"""Load accounts and user keys from VikingFS into memory."""
accounts_data = await self._read_json(ACCOUNTS_PATH)
+ fresh_workspace = accounts_data is None
if accounts_data is None:
# First run: create default account
now = datetime.now(timezone.utc).isoformat()
@@ -92,11 +100,28 @@ class APIKeyManager:
users_path = USERS_PATH_TEMPLATE.format(account_id=account_id)
users_data = await self._read_json(users_path)
users = users_data.get("users", {}) if users_data else {}
+ settings_path = SETTINGS_PATH_TEMPLATE.format(account_id=account_id)
+ settings_data = await self._read_json(settings_path)
+ namespace_policy, should_persist_settings, inferred_from_legacy = (
+ self._resolve_namespace_policy(
+ settings_data,
+ allow_legacy_inference=not fresh_workspace,
+ )
+ )
self._accounts[account_id] = AccountInfo(
created_at=info.get("created_at", ""),
users=users,
+ namespace_policy=namespace_policy,
)
+ if should_persist_settings:
+ await self._save_settings_json(account_id, settings_data=settings_data)
+ if inferred_from_legacy:
+ logger.info(
+ "Inferred namespace policy for legacy account %s using the historical "
+ "default user-shared/agent-shared layout",
+ account_id,
+ )
for user_id, user_info in users.items():
key_or_hash = user_info.get("key", "")
@@ -148,6 +173,28 @@ class APIKeyManager:
sum(len(info.users) for info in self._accounts.values()),
)
+ def _resolve_namespace_policy(
+ self,
+ settings_data: Optional[dict],
+ *,
+ allow_legacy_inference: bool,
+ ) -> tuple[AccountNamespacePolicy, bool, bool]:
+ """Resolve persisted namespace policy, with one-time inference for legacy accounts."""
+ namespace_data = settings_data.get("namespace") if isinstance(settings_data, dict) else None
+ if isinstance(namespace_data, dict):
+ return AccountNamespacePolicy.from_dict(namespace_data), False, False
+
+ if allow_legacy_inference:
+ return self._infer_legacy_namespace_policy(), True, True
+ return AccountNamespacePolicy(), True, False
+
+ def _infer_legacy_namespace_policy(self) -> AccountNamespacePolicy:
+ """Map pre-policy accounts to the compatibility default namespace policy."""
+ return AccountNamespacePolicy(
+ isolate_user_scope_by_agent=False,
+ isolate_agent_scope_by_user=False,
+ )
+
def resolve(self, api_key: str) -> ResolvedIdentity:
"""Resolve an API key to identity. Sequential matching: root key first, then user key index."""
if not api_key:
@@ -168,6 +215,7 @@ class APIKeyManager:
role=entry.role,
account_id=entry.account_id,
user_id=entry.user_id,
+ namespace_policy=self.get_account_policy(entry.account_id),
)
else:
# Verify plaintext key
@@ -176,11 +224,18 @@ class APIKeyManager:
role=entry.role,
account_id=entry.account_id,
user_id=entry.user_id,
+ namespace_policy=self.get_account_policy(entry.account_id),
)
raise UnauthenticatedError("Invalid API Key")
- async def create_account(self, account_id: str, admin_user_id: str) -> str:
+ async def create_account(
+ self,
+ account_id: str,
+ admin_user_id: str,
+ *,
+ namespace_policy: Optional[AccountNamespacePolicy] = None,
+ ) -> str:
"""Create a new account (workspace) with its first admin user.
Returns the admin user's API key.
@@ -190,6 +245,7 @@ class APIKeyManager:
now = datetime.now(timezone.utc).isoformat()
key = self._generate_api_key()
+ policy = namespace_policy or AccountNamespacePolicy()
if self._encryption_enabled:
stored_key = self._hash_api_key(key)
@@ -210,6 +266,7 @@ class APIKeyManager:
self._accounts[account_id] = AccountInfo(
created_at=now,
users={admin_user_id: user_info},
+ namespace_policy=policy,
)
entry = UserKeyEntry(
@@ -228,6 +285,7 @@ class APIKeyManager:
await self._save_accounts_json()
await self._save_users_json(account_id)
+ await self._save_settings_json(account_id)
return key
async def delete_account(self, account_id: str) -> None:
@@ -435,10 +493,19 @@ class APIKeyManager:
"account_id": account_id,
"created_at": info.created_at,
"user_count": len(info.users),
+ **info.namespace_policy.to_dict(),
}
)
return result
+ def get_account_policy(self, account_id: Optional[str]) -> AccountNamespacePolicy:
+ if not account_id:
+ return AccountNamespacePolicy()
+ account = self._accounts.get(account_id)
+ if account is None:
+ return AccountNamespacePolicy()
+ return account.namespace_policy
+
def get_users(self, account_id: str) -> list:
"""List all users in an account."""
account = self._accounts.get(account_id)
@@ -455,6 +522,13 @@ class APIKeyManager:
)
return result
+ def has_user(self, account_id: str, user_id: str) -> bool:
+ """Return True when the account registry contains the given user."""
+ account = self._accounts.get(account_id)
+ if account is None:
+ return False
+ return user_id in account.users
+
# ---- internal helpers ----
def _generate_api_key(self) -> str:
@@ -557,3 +631,18 @@ class APIKeyManager:
data = {"users": account.users}
path = USERS_PATH_TEMPLATE.format(account_id=account_id)
await self._write_json(path, data)
+
+ async def _save_settings_json(
+ self,
+ account_id: str,
+ *,
+ settings_data: Optional[dict] = None,
+ ) -> None:
+ """Persist account namespace settings."""
+ account = self._accounts.get(account_id)
+ if account is None:
+ return
+ path = SETTINGS_PATH_TEMPLATE.format(account_id=account_id)
+ merged_settings = dict(settings_data) if isinstance(settings_data, dict) else {}
+ merged_settings["namespace"] = account.namespace_policy.to_dict()
+ await self._write_json(path, merged_settings)
diff --git a/openviking/server/app.py b/openviking/server/app.py
index d173b474c..b85eb672d 100644
--- a/openviking/server/app.py
+++ b/openviking/server/app.py
@@ -83,7 +83,8 @@ def create_app(
await api_key_manager.load()
app.state.api_key_manager = api_key_manager
logger.info(
- "APIKeyManager initialized with encryption_enabled=%s", config.encryption_enabled
+ "APIKeyManager initialized with encryption_enabled=%s",
+ config.encryption_enabled,
)
elif config.auth_mode == "trusted":
app.state.api_key_manager = None
diff --git a/openviking/server/auth.py b/openviking/server/auth.py
index 59d585abe..ac868aed3 100644
--- a/openviking/server/auth.py
+++ b/openviking/server/auth.py
@@ -116,10 +116,30 @@ async def resolve_identity(
raise UnauthenticatedError("Missing API Key when resolving identity.")
identity = api_key_manager.resolve(api_key)
- identity.agent_id = x_openviking_agent or "default"
if identity.role == Role.ROOT:
identity.account_id = x_openviking_account or identity.account_id or "default"
identity.user_id = x_openviking_user or identity.user_id or "default"
+ identity.agent_id = x_openviking_agent or identity.agent_id or "default"
+ return identity
+
+ identity.account_id = identity.account_id or "default"
+ if x_openviking_account and x_openviking_account != identity.account_id:
+ raise PermissionDeniedError(
+ "X-OpenViking-Account cannot override the account for ADMIN/USER API keys."
+ )
+
+ if identity.role == Role.ADMIN:
+ identity.user_id = x_openviking_user or identity.user_id or "default"
+ identity.agent_id = x_openviking_agent or identity.agent_id or "default"
+ return identity
+
+ identity.user_id = identity.user_id or "default"
+ if x_openviking_user and x_openviking_user != identity.user_id:
+ raise PermissionDeniedError(
+ "USER API keys cannot override X-OpenViking-User; the effective user is derived "
+ "from the key."
+ )
+ identity.agent_id = x_openviking_agent or identity.agent_id or "default"
return identity
@@ -157,6 +177,11 @@ async def get_request_context(
identity.agent_id or "default",
),
role=identity.role,
+ namespace_policy=(
+ api_key_manager.get_account_policy(identity.account_id)
+ if api_key_manager is not None
+ else identity.namespace_policy
+ ),
)
request.state.metric_account_id = ctx.account_id
set_metric_account_context(account_id=ctx.account_id)
diff --git a/openviking/server/identity.py b/openviking/server/identity.py
index 0fae4a328..6e35049ca 100644
--- a/openviking/server/identity.py
+++ b/openviking/server/identity.py
@@ -15,6 +15,29 @@ class Role(str, Enum):
USER = "user"
+@dataclass(frozen=True)
+class AccountNamespacePolicy:
+ """Account-level namespace isolation policy."""
+
+ isolate_user_scope_by_agent: bool = False
+ isolate_agent_scope_by_user: bool = False
+
+ @classmethod
+ def from_dict(cls, data: Optional[dict]) -> "AccountNamespacePolicy":
+ if not isinstance(data, dict):
+ return cls()
+ return cls(
+ isolate_user_scope_by_agent=bool(data.get("isolate_user_scope_by_agent", False)),
+ isolate_agent_scope_by_user=bool(data.get("isolate_agent_scope_by_user", False)),
+ )
+
+ def to_dict(self) -> dict:
+ return {
+ "isolate_user_scope_by_agent": self.isolate_user_scope_by_agent,
+ "isolate_agent_scope_by_user": self.isolate_agent_scope_by_user,
+ }
+
+
@dataclass
class ResolvedIdentity:
"""Output of auth middleware: raw identity resolved from API Key."""
@@ -23,6 +46,7 @@ class ResolvedIdentity:
account_id: Optional[str] = None
user_id: Optional[str] = None
agent_id: Optional[str] = None
+ namespace_policy: AccountNamespacePolicy = field(default_factory=AccountNamespacePolicy)
@dataclass
@@ -31,6 +55,7 @@ class RequestContext:
user: UserIdentifier
role: Role
+ namespace_policy: AccountNamespacePolicy = field(default_factory=AccountNamespacePolicy)
@property
def account_id(self) -> str:
diff --git a/openviking/server/routers/admin.py b/openviking/server/routers/admin.py
index 9e0e5682d..8f7fe3456 100644
--- a/openviking/server/routers/admin.py
+++ b/openviking/server/routers/admin.py
@@ -7,7 +7,7 @@ from pydantic import BaseModel
from openviking.server.auth import get_request_context
from openviking.server.dependencies import get_service
-from openviking.server.identity import RequestContext, Role
+from openviking.server.identity import AccountNamespacePolicy, RequestContext, Role
from openviking.server.models import Response
from openviking.storage.viking_fs import get_viking_fs
from openviking_cli.exceptions import PermissionDeniedError
@@ -33,6 +33,8 @@ _DEV_MODE_ADMIN_API_MESSAGE = (
class CreateAccountRequest(BaseModel):
account_id: str
admin_user_id: str
+ isolate_user_scope_by_agent: bool = False
+ isolate_agent_scope_by_user: bool = False
class RegisterUserRequest(BaseModel):
@@ -94,11 +96,20 @@ async def create_account(
):
"""Create a new account (workspace) with its first admin user."""
manager = _get_api_key_manager(request)
- user_key = await manager.create_account(body.account_id, body.admin_user_id)
+ policy = AccountNamespacePolicy(
+ isolate_user_scope_by_agent=body.isolate_user_scope_by_agent,
+ isolate_agent_scope_by_user=body.isolate_agent_scope_by_user,
+ )
+ user_key = await manager.create_account(
+ body.account_id,
+ body.admin_user_id,
+ namespace_policy=policy,
+ )
service = get_service()
account_ctx = RequestContext(
user=UserIdentifier(body.account_id, body.admin_user_id, "default"),
role=Role.ADMIN,
+ namespace_policy=policy,
)
await service.initialize_account_directories(account_ctx)
await service.initialize_user_directories(account_ctx)
@@ -108,6 +119,7 @@ async def create_account(
"account_id": body.account_id,
"admin_user_id": body.admin_user_id,
"user_key": user_key,
+ **policy.to_dict(),
},
)
@@ -184,6 +196,7 @@ async def register_user(
user_ctx = RequestContext(
user=UserIdentifier(account_id, body.user_id, "default"),
role=Role.USER,
+ namespace_policy=manager.get_account_policy(account_id),
)
await service.initialize_user_directories(user_ctx)
return Response(
diff --git a/openviking/server/routers/sessions.py b/openviking/server/routers/sessions.py
index 919459a69..0c7cecc63 100644
--- a/openviking/server/routers/sessions.py
+++ b/openviking/server/routers/sessions.py
@@ -3,20 +3,22 @@
"""Sessions endpoints for OpenViking HTTP Server."""
import logging
-from datetime import datetime
+import re
from typing import Any, Dict, List, Literal, Optional
-from fastapi import APIRouter, Depends, Path, Query
+from fastapi import APIRouter, Depends, Path, Query, Request
from pydantic import BaseModel, model_validator
from openviking.message.part import TextPart, part_from_dict
from openviking.server.auth import get_request_context
from openviking.server.dependencies import get_service
-from openviking.server.identity import RequestContext
+from openviking.server.identity import RequestContext, Role
from openviking.server.models import ErrorInfo, Response
+from openviking_cli.exceptions import InvalidArgumentError
router = APIRouter(prefix="/api/v1/sessions", tags=["sessions"])
logger = logging.getLogger(__name__)
+_ROLE_ID_PATTERN = re.compile(r"^[a-zA-Z0-9_-]+$")
class TextPartRequest(BaseModel):
@@ -62,6 +64,7 @@ class AddMessageRequest(BaseModel):
"""
role: str
+ role_id: Optional[str] = None
content: Optional[str] = None
parts: Optional[List[Dict[str, Any]]] = None
created_at: Optional[str] = None
@@ -98,6 +101,47 @@ def _to_jsonable(value: Any) -> Any:
return value
+def _request_auth_mode(request: Request) -> str:
+ config = getattr(request.app.state, "config", None)
+ return getattr(config, "auth_mode", "api_key")
+
+
+def _resolve_message_role_id(
+ http_request: Request,
+ request: AddMessageRequest,
+ ctx: RequestContext,
+) -> Optional[str]:
+ if request.role not in {"user", "assistant"}:
+ return request.role_id
+
+ role_id_provided = "role_id" in request.model_fields_set
+ allow_explicit_role_id = _request_auth_mode(http_request) == "trusted" or ctx.role in {
+ Role.ROOT,
+ Role.ADMIN,
+ }
+ if not allow_explicit_role_id and role_id_provided:
+ raise InvalidArgumentError(
+ "USER requests cannot explicitly set role_id; it is derived from the request context."
+ )
+
+ role_id = request.role_id if allow_explicit_role_id else None
+ if not role_id:
+ role_id = ctx.user.user_id if request.role == "user" else ctx.user.agent_id
+
+ if not _ROLE_ID_PATTERN.match(role_id):
+ raise InvalidArgumentError("role_id must be alpha-numeric string.")
+
+ if request.role == "user":
+ api_key_manager = getattr(http_request.app.state, "api_key_manager", None)
+ has_user = getattr(api_key_manager, "has_user", None)
+ if callable(has_user) and not has_user(ctx.account_id, role_id):
+ raise InvalidArgumentError(
+ f"role_id '{role_id}' is not a registered user in account '{ctx.account_id}'."
+ )
+
+ return role_id
+
+
@router.post("")
async def create_session(
request: Optional[CreateSessionRequest] = None,
@@ -233,6 +277,7 @@ async def extract_session(
@router.post("/{session_id}/messages")
async def add_message(
request: AddMessageRequest,
+ http_request: Request,
session_id: str = Path(..., description="Session ID"),
_ctx: RequestContext = Depends(get_request_context),
):
@@ -253,6 +298,7 @@ async def add_message(
"""
service = get_service()
session = await service.sessions.get(session_id, _ctx, auto_create=True)
+ role_id = _resolve_message_role_id(http_request, request, _ctx)
if request.parts is not None:
parts = [part_from_dict(p) for p in request.parts]
@@ -260,7 +306,12 @@ async def add_message(
parts = [TextPart(text=request.content or "")]
# created_at 直接传递给 session (ISO string)
- session.add_message(request.role, parts, created_at=request.created_at)
+ session.add_message(
+ request.role,
+ parts,
+ role_id=role_id,
+ created_at=request.created_at,
+ )
return Response(
status="ok",
result={
diff --git a/openviking/service/core.py b/openviking/service/core.py
index 771cdb609..ae9851ab2 100644
--- a/openviking/service/core.py
+++ b/openviking/service/core.py
@@ -282,7 +282,10 @@ class OpenVikingService:
logger.info("QueueManager workers started")
# Initialize directories
- directory_initializer = DirectoryInitializer(vikingdb=self._vikingdb_manager)
+ directory_initializer = DirectoryInitializer(
+ vikingdb=self._vikingdb_manager,
+ viking_fs=self._viking_fs,
+ )
self._directory_initializer = directory_initializer
default_ctx = RequestContext(user=self._user, role=Role.ROOT)
account_count = await directory_initializer.initialize_account_directories(default_ctx)
diff --git a/openviking/service/session_service.py b/openviking/service/session_service.py
index e81be1b35..e5772714b 100644
--- a/openviking/service/session_service.py
+++ b/openviking/service/session_service.py
@@ -8,7 +8,8 @@ Provides session management operations: session, sessions, add_message, commit,
from typing import Any, Dict, List, Optional
-from openviking.server.identity import RequestContext
+from openviking.core.namespace import canonical_session_uri
+from openviking.server.identity import RequestContext, Role
from openviking.service.task_tracker import get_task_tracker
from openviking.session import Session
from openviking.session.compressor import SessionCompressor
@@ -149,7 +150,7 @@ class SessionService:
List of session info dicts
"""
self._ensure_initialized()
- session_base_uri = f"viking://session/{ctx.user.user_space_name()}"
+ session_base_uri = canonical_session_uri()
try:
entries = await self._viking_fs.ls(session_base_uri, ctx=ctx)
@@ -179,7 +180,12 @@ class SessionService:
True if deleted successfully
"""
self._ensure_initialized()
- session_uri = f"viking://session/{ctx.user.user_space_name()}/{session_id}"
+ if ctx.role not in {Role.ADMIN, Role.ROOT}:
+ from openviking_cli.exceptions import PermissionDeniedError
+
+ raise PermissionDeniedError("Deleting shared sessions requires ADMIN or ROOT role")
+
+ session_uri = canonical_session_uri(session_id)
try:
await self._viking_fs.rm(session_uri, recursive=True, ctx=ctx)
@@ -248,7 +254,6 @@ class SessionService:
task = get_task_tracker().get(
task_id,
owner_account_id=ctx.account_id,
- owner_user_id=ctx.user.user_id,
)
return task.to_dict() if task else None
diff --git a/openviking/session/compressor_v2.py b/openviking/session/compressor_v2.py
index 2d5ce523f..0afda749d 100644
--- a/openviking/session/compressor_v2.py
+++ b/openviking/session/compressor_v2.py
@@ -11,16 +11,16 @@ import asyncio
from typing import List, Optional
from openviking.core.context import Context
+from openviking.core.namespace import agent_space_fragment, user_space_fragment
from openviking.message import Message
from openviking.server.identity import RequestContext
from openviking.session.memory import ExtractLoop, MemoryUpdater
from openviking.session.memory.utils.json_parser import JsonUtils
from openviking.storage import VikingDBManager
from openviking.storage.viking_fs import get_viking_fs
-from openviking.telemetry import get_current_telemetry
+from openviking.telemetry import get_current_telemetry, tracer
from openviking_cli.session.user_id import UserIdentifier
from openviking_cli.utils import get_logger
-from openviking.telemetry import tracer
from openviking_cli.utils.config import get_openviking_config
logger = get_logger(__name__)
@@ -150,8 +150,8 @@ class SessionCompressorV2:
for schema in schemas:
if not schema.directory:
continue
- user_space = ctx.user.user_space_name() if ctx and ctx.user else "default"
- agent_space = ctx.user.agent_space_name() if ctx and ctx.user else "default"
+ user_space = user_space_fragment(ctx) if ctx and ctx.user else "default"
+ agent_space = agent_space_fragment(ctx) if ctx and ctx.user else "default"
# 使用 Jinja2 渲染 directory
import jinja2
@@ -225,7 +225,9 @@ class SessionCompressorV2:
extract_context = ExtractContext(messages)
# Apply operations
- result = await updater.apply_operations(operations, ctx, extract_context=extract_context)
+ result = await updater.apply_operations(
+ operations, ctx, extract_context=extract_context
+ )
tracer.info(
f"Applied memory operations: written={len(result.written_uris)}, "
diff --git a/openviking/session/memory/extract_loop.py b/openviking/session/memory/extract_loop.py
index 191a19340..ffd521e6c 100644
--- a/openviking/session/memory/extract_loop.py
+++ b/openviking/session/memory/extract_loop.py
@@ -10,6 +10,7 @@ import asyncio
import json
from typing import Any, Dict, List, Optional, Set, Tuple
+from openviking.core.namespace import agent_space_fragment, user_space_fragment
from openviking.models.vlm.base import VLMBase
from openviking.server.identity import RequestContext
from openviking.session.memory.schema_model_generator import (
@@ -330,8 +331,8 @@ The final output of the model must strictly follow the JSON Schema format shown
operations,
schemas,
registry,
- user_space=self.ctx.user.user_space_name(),
- agent_space=self.ctx.user.agent_space_name(),
+ user_space=user_space_fragment(self.ctx),
+ agent_space=agent_space_fragment(self.ctx),
extract_context=self._extract_context,
)
if not is_valid:
@@ -502,8 +503,8 @@ The final output of the model must strictly follow the JSON Schema format shown
uri = resolve_flat_model_uri(
item_dict,
registry,
- user_space=self.ctx.user.user_space_name(),
- agent_space=self.ctx.user.agent_space_name(),
+ user_space=user_space_fragment(self.ctx),
+ agent_space=agent_space_fragment(self.ctx),
memory_type=field_name,
extract_context=self._extract_context,
)
diff --git a/openviking/session/memory/memory_type_registry.py b/openviking/session/memory/memory_type_registry.py
index dca13ca68..b3a6aa069 100644
--- a/openviking/session/memory/memory_type_registry.py
+++ b/openviking/session/memory/memory_type_registry.py
@@ -9,6 +9,7 @@ from typing import Any, Dict, List, Optional
import yaml
+from openviking.core.namespace import agent_space_fragment, user_space_fragment
from openviking.session.memory.dataclass import MemoryField, MemoryTypeSchema
from openviking.session.memory.merge_op import MergeOp
from openviking.session.memory.merge_op.base import FieldType
@@ -205,8 +206,8 @@ class MemoryTypeRegistry:
logger = get_logger(__name__)
- user_space = ctx.user.user_space_name() if ctx and ctx.user else "default"
- agent_space = ctx.user.agent_space_name() if ctx and ctx.user else "default"
+ user_space = user_space_fragment(ctx) if ctx and ctx.user else "default"
+ agent_space = agent_space_fragment(ctx) if ctx and ctx.user else "default"
logger.info(
f"[MemoryTypeRegistry] Starting memory files initialization for user={user_space}, agent={agent_space}"
diff --git a/openviking/session/memory/memory_updater.py b/openviking/session/memory/memory_updater.py
index cad4869d9..631b41202 100644
--- a/openviking/session/memory/memory_updater.py
+++ b/openviking/session/memory/memory_updater.py
@@ -10,11 +10,13 @@ to the storage system.
from typing import Any, Dict, List, Optional, Tuple
import jinja2
+
+from openviking.core.namespace import agent_space_fragment, user_space_fragment
from openviking.message import Message
from openviking.server.identity import RequestContext
from openviking.session.memory.dataclass import MemoryField
from openviking.session.memory.memory_type_registry import MemoryTypeRegistry
-from openviking.session.memory.merge_op import MergeOpFactory, PatchOp
+from openviking.session.memory.merge_op import MergeOpFactory
from openviking.session.memory.utils import (
deserialize_full,
flat_model_to_dict,
@@ -270,8 +272,8 @@ class MemoryUpdater:
raise ValueError("MemoryTypeRegistry is required for URI resolution")
# Get actual user/agent space from ctx
- user_space = ctx.user.user_space_name() if ctx and ctx.user else "default"
- agent_space = ctx.user.agent_space_name() if ctx and ctx.user else "default"
+ user_space = user_space_fragment(ctx) if ctx and ctx.user else "default"
+ agent_space = agent_space_fragment(ctx) if ctx and ctx.user else "default"
# Resolve all URIs first (pass extract_context for template rendering)
resolved_ops = resolve_all_operations(
@@ -339,8 +341,8 @@ class MemoryUpdater:
if schema.overview_template and schema.directory:
env = jinja2.Environment(autoescape=False)
base_dir = env.from_string(schema.directory).render(
- user_space=ctx.user.user_space_name(),
- agent_space=ctx.user.agent_space_name(),
+ user_space=user_space,
+ agent_space=agent_space,
)
# Check if this uri belongs to this memory type's directory
if dir_path.startswith(base_dir.rstrip("/")):
@@ -350,7 +352,9 @@ class MemoryUpdater:
# Generate overview for each unique directory
for directory, memory_type in dir_to_memory_type.items():
- logger.info(f"[apply_operations] Generating overview for {memory_type} at {directory}")
+ logger.info(
+ f"[apply_operations] Generating overview for {memory_type} at {directory}"
+ )
await self.generate_overview(memory_type, directory, ctx, extract_context)
return result
@@ -566,13 +570,17 @@ class MemoryUpdater:
"""
from openviking.session.memory.utils.messages import parse_memory_file_with_fields
- tracer.info(f"[generate_overview] Called with memory_type={memory_type}, directory={directory}")
+ tracer.info(
+ f"[generate_overview] Called with memory_type={memory_type}, directory={directory}"
+ )
# Get the schema for this memory type
registry = self._registry
tracer.info(f"[generate_overview] registry={registry}")
schema = registry.get(memory_type)
- tracer.info(f"[generate_overview] schema={schema}, overview_template={schema.overview_template if schema else None}")
+ tracer.info(
+ f"[generate_overview] schema={schema}, overview_template={schema.overview_template if schema else None}"
+ )
if not schema or not schema.overview_template:
logger.debug(f"No overview_template for memory type: {memory_type}")
return
@@ -590,7 +598,11 @@ class MemoryUpdater:
base_uri = directory.rstrip("/")
for entry in entries:
name = entry.get("name", "")
- if name.endswith(".md") and not name.endswith(".overview.md") and not name.endswith(".abstract.md"):
+ if (
+ name.endswith(".md")
+ and not name.endswith(".overview.md")
+ and not name.endswith(".abstract.md")
+ ):
md_files.append(f"{base_uri}/{name}")
tracer.info(f"[generate_overview] Filtered md_files: {md_files}")
@@ -620,15 +632,19 @@ class MemoryUpdater:
try:
content = await viking_fs.read_file(file_path, ctx=ctx)
parsed = parse_memory_file_with_fields(content)
- tracer.info(f"[generate_overview] Parsed {file_path}: {parsed.keys() if parsed else None}")
+ tracer.info(
+ f"[generate_overview] Parsed {file_path}: {parsed.keys() if parsed else None}"
+ )
# Extract filename from path
filename = file_path.split("/")[-1]
- items.append({
- "file_name": filename,
- "file_content": parsed,
- })
+ items.append(
+ {
+ "file_name": filename,
+ "file_content": parsed,
+ }
+ )
except Exception as e:
logger.warning(f"Failed to parse {file_path}: {e}")
continue
diff --git a/openviking/session/memory/session_extract_context_provider.py b/openviking/session/memory/session_extract_context_provider.py
index f5a97c6c7..f0ab659ee 100644
--- a/openviking/session/memory/session_extract_context_provider.py
+++ b/openviking/session/memory/session_extract_context_provider.py
@@ -8,8 +8,9 @@ Session Extract Context Provider - 会话提取 Provider 实现
import json
import os
-from typing import Any, Dict, List
+from typing import TYPE_CHECKING, Any, Dict, List
+from openviking.core.namespace import agent_space_fragment, user_space_fragment
from openviking.server.identity import RequestContext
from openviking.session.memory.core import ExtractContextProvider
from openviking.session.memory.memory_type_registry import MemoryTypeRegistry
@@ -18,12 +19,14 @@ from openviking.session.memory.tools import (
get_tool,
)
from openviking.storage.viking_fs import VikingFS
-from openviking.telemetry import tracer
from openviking_cli.utils import get_logger
from openviking_cli.utils.config import get_openviking_config
logger = get_logger(__name__)
+if TYPE_CHECKING:
+ from openviking.session.memory.memory_updater import ExtractContext
+
class SessionExtractContextProvider(ExtractContextProvider):
"""会话提取 Provider - 从会话消息中提取记忆"""
@@ -96,7 +99,6 @@ The system automatically generates URIs based on memory_type and fields. Just pr
See GenericOverviewEdit in the JSON Schema below.
"""
-
def _build_conversation_message(self) -> Dict[str, Any]:
"""构建包含 Conversation History 的 user message"""
from datetime import datetime
@@ -233,8 +235,8 @@ After exploring, analyze the conversation and output ALL memory write/edit/delet
continue
# Replace variables in directory path with actual user/agent space
- user_space = ctx.user.user_space_name() if ctx and ctx.user else "default"
- agent_space = ctx.user.agent_space_name() if ctx and ctx.user else "default"
+ user_space = user_space_fragment(ctx) if ctx and ctx.user else "default"
+ agent_space = agent_space_fragment(ctx) if ctx and ctx.user else "default"
import jinja2
env = jinja2.Environment(autoescape=False)
diff --git a/openviking/session/memory_deduplicator.py b/openviking/session/memory_deduplicator.py
index c57ae8216..22369696c 100644
--- a/openviking/session/memory_deduplicator.py
+++ b/openviking/session/memory_deduplicator.py
@@ -15,6 +15,7 @@ from enum import Enum
from typing import Dict, List, Optional
from openviking.core.context import Context
+from openviking.core.namespace import canonical_agent_root, canonical_user_root
from openviking.models.embedder.base import EmbedResult, embed_compat
from openviking.prompts import render_prompt
from openviking.server.identity import RequestContext
@@ -74,12 +75,12 @@ class MemoryDeduplicator:
_AGENT_CATEGORIES = {"cases", "patterns", "tools", "skills"}
@staticmethod
- def _category_uri_prefix(category: str, user) -> str:
+ def _category_uri_prefix(category: str, ctx: RequestContext) -> str:
"""Build category URI prefix with space segment."""
if category in MemoryDeduplicator._USER_CATEGORIES:
- return f"viking://user/{user.user_space_name()}/memories/{category}/"
+ return f"{canonical_user_root(ctx)}/memories/{category}/"
elif category in MemoryDeduplicator._AGENT_CATEGORIES:
- return f"viking://agent/{user.agent_space_name()}/memories/{category}/"
+ return f"{canonical_agent_root(ctx)}/memories/{category}/"
return ""
def __init__(
@@ -154,27 +155,18 @@ class MemoryDeduplicator:
embed_result: EmbedResult = await embed_compat(self.embedder, query_text, is_query=True)
query_vector = embed_result.dense_vector
- category_uri_prefix = self._category_uri_prefix(candidate.category.value, candidate.user)
-
- owner = candidate.user
- owner_space = None
- if owner and hasattr(owner, "user_space_name"):
- owner_space = (
- owner.agent_space_name()
- if candidate.category.value in {"cases", "patterns"}
- else owner.user_space_name()
- )
+ category_uri_prefix = self._category_uri_prefix(candidate.category.value, ctx)
logger.debug(
"Dedup prefilter candidate category=%s owner_space=%s uri_prefix=%s",
candidate.category.value,
- owner_space,
+ None,
category_uri_prefix,
)
try:
# Search with memory-scope filter.
results = await self.vikingdb.search_similar_memories(
- owner_space=owner_space,
+ owner_space=None,
category_uri_prefix=category_uri_prefix,
query_vector=query_vector,
limit=5,
diff --git a/openviking/session/memory_extractor.py b/openviking/session/memory_extractor.py
index fefef0ba7..1ea96434a 100644
--- a/openviking/session/memory_extractor.py
+++ b/openviking/session/memory_extractor.py
@@ -15,6 +15,7 @@ from typing import List, Optional
from uuid import uuid4
from openviking.core.context import Context, ContextType, Vectorize
+from openviking.core.namespace import canonical_agent_root, canonical_user_root
from openviking.prompts import render_prompt
from openviking.server.identity import RequestContext
from openviking.storage.viking_fs import get_viking_fs
@@ -141,8 +142,8 @@ class MemoryExtractor:
CASES / PATTERNS → agent_space
"""
if category in MemoryExtractor._USER_CATEGORIES:
- return ctx.user.user_space_name()
- return ctx.user.agent_space_name()
+ return ctx.user.user_id
+ return ctx.user.agent_id
@staticmethod
def _detect_output_language(messages: List, fallback_language: str = "en") -> str:
@@ -459,11 +460,11 @@ class MemoryExtractor:
payload = await self._append_to_profile(candidate, viking_fs, ctx=ctx)
if not payload:
return None
- user_space = ctx.user.user_space_name()
- memory_uri = f"viking://user/{user_space}/memories/profile.md"
+ user_root = canonical_user_root(ctx)
+ memory_uri = f"{user_root}/memories/profile.md"
memory = Context(
uri=memory_uri,
- parent_uri=f"viking://user/{user_space}/memories",
+ parent_uri=f"{user_root}/memories",
is_leaf=True,
abstract=payload.abstract,
context_type=ContextType.MEMORY.value,
@@ -484,9 +485,9 @@ class MemoryExtractor:
MemoryCategory.ENTITIES,
MemoryCategory.EVENTS,
]:
- parent_uri = f"viking://user/{ctx.user.user_space_name()}/{cat_dir}"
+ parent_uri = f"{canonical_user_root(ctx)}/{cat_dir}"
else: # CASES, PATTERNS
- parent_uri = f"viking://agent/{ctx.user.agent_space_name()}/{cat_dir}"
+ parent_uri = f"{canonical_agent_root(ctx)}/{cat_dir}"
# Generate file URI (store directly as .md file, no directory creation)
memory_id = f"mem_{str(uuid4())}"
@@ -524,7 +525,7 @@ class MemoryExtractor:
ctx: RequestContext,
) -> Optional[MergedMemoryPayload]:
"""Update user profile - always merge with existing content."""
- uri = f"viking://user/{ctx.user.user_space_name()}/memories/profile.md"
+ uri = f"{canonical_user_root(ctx)}/memories/profile.md"
existing = ""
try:
existing = await viking_fs.read_file(uri, ctx=ctx) or ""
@@ -632,8 +633,8 @@ class MemoryExtractor:
logger.warning("Tool name is empty, skipping tool memory merge")
return None
- agent_space = ctx.user.agent_space_name()
- uri = f"viking://agent/{agent_space}/memories/tools/{tool_name}.md"
+ agent_root = canonical_agent_root(ctx)
+ uri = f"{agent_root}/memories/tools/{tool_name}.md"
viking_fs = get_viking_fs()
if not viking_fs:
@@ -1144,10 +1145,10 @@ class MemoryExtractor:
abstract_override: Optional[str] = None,
) -> Context:
"""创建 Tool Memory 的 Context 对象"""
- agent_space = ctx.user.agent_space_name()
+ agent_root = canonical_agent_root(ctx)
return Context(
uri=uri,
- parent_uri=f"viking://agent/{agent_space}/memories/tools",
+ parent_uri=f"{agent_root}/memories/tools",
is_leaf=True,
abstract=abstract_override or candidate.abstract,
context_type=ContextType.MEMORY.value,
@@ -1155,7 +1156,7 @@ class MemoryExtractor:
session_id=candidate.source_session,
user=candidate.user,
account_id=ctx.account_id,
- owner_space=agent_space,
+ owner_space=ctx.user.agent_id,
)
def _extract_tool_guidelines(self, content: str) -> str:
@@ -1186,8 +1187,8 @@ class MemoryExtractor:
logger.warning("Skill name is empty, skipping skill memory merge")
return None
- agent_space = ctx.user.agent_space_name()
- uri = f"viking://agent/{agent_space}/memories/skills/{skill_name}.md"
+ agent_root = canonical_agent_root(ctx)
+ uri = f"{agent_root}/memories/skills/{skill_name}.md"
viking_fs = get_viking_fs()
if not viking_fs:
@@ -1472,10 +1473,10 @@ class MemoryExtractor:
abstract_override: Optional[str] = None,
) -> Context:
"""创建 Skill Memory 的 Context 对象"""
- agent_space = ctx.user.agent_space_name()
+ agent_root = canonical_agent_root(ctx)
return Context(
uri=uri,
- parent_uri=f"viking://agent/{agent_space}/memories/skills",
+ parent_uri=f"{agent_root}/memories/skills",
is_leaf=True,
abstract=abstract_override or candidate.abstract,
context_type=ContextType.MEMORY.value,
@@ -1483,7 +1484,7 @@ class MemoryExtractor:
session_id=candidate.source_session,
user=candidate.user,
account_id=ctx.account_id,
- owner_space=agent_space,
+ owner_space=ctx.user.agent_id,
)
def _extract_skill_guidelines(self, content: str) -> str:
diff --git a/openviking/session/session.py b/openviking/session/session.py
index b6ec14965..a9da3d441 100644
--- a/openviking/session/session.py
+++ b/openviking/session/session.py
@@ -13,6 +13,7 @@ from datetime import datetime, timezone
from typing import TYPE_CHECKING, Any, Dict, List, Optional
from uuid import uuid4
+from openviking.core.namespace import canonical_session_uri
from openviking.message import Message, Part
from openviking.server.identity import RequestContext, Role
from openviking.telemetry import get_current_telemetry, tracer
@@ -60,6 +61,9 @@ class SessionMeta:
session_id: str = ""
created_at: str = ""
updated_at: str = ""
+ created_by_user_id: str = ""
+ participant_user_ids: List[str] = field(default_factory=list)
+ participant_agent_ids: List[str] = field(default_factory=list)
message_count: int = 0
commit_count: int = 0
memories_extracted: Dict[str, int] = field(
@@ -94,6 +98,9 @@ class SessionMeta:
"session_id": self.session_id,
"created_at": self.created_at,
"updated_at": self.updated_at,
+ "created_by_user_id": self.created_by_user_id,
+ "participant_user_ids": list(self.participant_user_ids),
+ "participant_agent_ids": list(self.participant_agent_ids),
"message_count": self.message_count,
"commit_count": self.commit_count,
"memories_extracted": dict(self.memories_extracted),
@@ -112,6 +119,9 @@ class SessionMeta:
session_id=data.get("session_id", ""),
created_at=data.get("created_at", ""),
updated_at=data.get("updated_at", ""),
+ created_by_user_id=data.get("created_by_user_id", ""),
+ participant_user_ids=list(data.get("participant_user_ids", [])),
+ participant_agent_ids=list(data.get("participant_agent_ids", [])),
message_count=data.get("message_count", 0),
commit_count=data.get("commit_count", 0),
memories_extracted={
@@ -171,13 +181,18 @@ class Session:
self.session_id = session_id or str(uuid4())
self.created_at = int(datetime.now(timezone.utc).timestamp() * 1000)
self._auto_commit_threshold = auto_commit_threshold
- self._session_uri = f"viking://session/{self.user.user_space_name()}/{self.session_id}"
+ self._session_uri = canonical_session_uri(self.session_id)
self._messages: List[Message] = []
self._usage_records: List[Usage] = []
self._compression: SessionCompression = SessionCompression()
self._stats: SessionStats = SessionStats()
- self._meta = SessionMeta(session_id=self.session_id, created_at=get_current_timestamp())
+ self._meta = SessionMeta(
+ session_id=self.session_id,
+ created_at=get_current_timestamp(),
+ created_by_user_id=self.ctx.user.user_id,
+ participant_user_ids=[self.ctx.user.user_id],
+ )
self._loaded = False
logger.info(f"Session created: {self.session_id} for user {self.user}")
@@ -225,6 +240,13 @@ class Session:
self._meta.message_count = len(self._messages)
self._meta.commit_count = self._compression.compression_index
+ if not self._meta.created_by_user_id:
+ self._meta.created_by_user_id = self.ctx.user.user_id
+ if not self._meta.participant_user_ids:
+ self._meta.participant_user_ids = [self._meta.created_by_user_id]
+ for message in self._messages:
+ self._record_participant(message)
+
self._loaded = True
async def exists(self) -> bool:
@@ -315,6 +337,7 @@ class Session:
self,
role: str,
parts: List[Part],
+ role_id: Optional[str] = None,
created_at: str = None,
) -> Message:
"""Add a message."""
@@ -322,9 +345,11 @@ class Session:
id=f"msg_{uuid4().hex}",
role=role,
parts=parts,
+ role_id=role_id,
created_at=created_at or datetime.now(timezone.utc).isoformat(),
)
self._messages.append(msg)
+ self._record_participant(msg)
# Update statistics
if role == "user":
@@ -337,6 +362,14 @@ class Session:
self._save_meta_sync()
return msg
+ def _record_participant(self, msg: Message) -> None:
+ if msg.role == "user" and msg.role_id:
+ if msg.role_id not in self._meta.participant_user_ids:
+ self._meta.participant_user_ids.append(msg.role_id)
+ if msg.role == "assistant" and msg.role_id:
+ if msg.role_id not in self._meta.participant_agent_ids:
+ self._meta.participant_agent_ids.append(msg.role_id)
+
def update_tool_part(
self,
message_id: str,
diff --git a/openviking/storage/collection_schemas.py b/openviking/storage/collection_schemas.py
index 030cd3f8b..f4d5a9d43 100644
--- a/openviking/storage/collection_schemas.py
+++ b/openviking/storage/collection_schemas.py
@@ -21,7 +21,6 @@ from openviking.server.identity import RequestContext, Role
from openviking.storage.errors import (
CollectionNotFoundError,
EmbeddingConfigurationError,
- EmbeddingRebuildRequiredError,
)
from openviking.storage.queuefs.embedding_msg import EmbeddingMsg
from openviking.storage.queuefs.named_queue import DequeueHandlerBase
@@ -103,7 +102,8 @@ class CollectionSchemas:
{"FieldName": "tags", "FieldType": "string"},
{"FieldName": "abstract", "FieldType": "string"},
{"FieldName": "account_id", "FieldType": "string"},
- {"FieldName": "owner_space", "FieldType": "string"},
+ {"FieldName": "owner_user_id", "FieldType": "string"},
+ {"FieldName": "owner_agent_id", "FieldType": "string"},
]
)
scalar_index = [
@@ -120,7 +120,8 @@ class CollectionSchemas:
"name",
"tags",
"account_id",
- "owner_space",
+ "owner_user_id",
+ "owner_agent_id",
]
)
return {
@@ -419,7 +420,7 @@ class TextEmbeddingHandler(DequeueHandlerBase):
self._breaker_open_suppressed_count = 0
except CircuitBreakerOpen:
self._log_breaker_open_reenqueue_summary()
- if self._vikingdb.has_queue_manager:
+ if getattr(self._vikingdb, "has_queue_manager", False):
wait = self._circuit_breaker.retry_after
if wait > 0:
await asyncio.sleep(wait)
@@ -489,7 +490,7 @@ class TextEmbeddingHandler(DequeueHandlerBase):
# Transient or unknown — re-enqueue for retry
logger.warning(error_msg)
self._circuit_breaker.record_failure(embed_err)
- if self._vikingdb.has_queue_manager:
+ if getattr(self._vikingdb, "has_queue_manager", False):
try:
await self._vikingdb.enqueue_embedding_msg(embedding_msg)
self._merge_request_stats(
diff --git a/openviking/storage/queuefs/embedding_msg_converter.py b/openviking/storage/queuefs/embedding_msg_converter.py
index cef13360c..6ea825ac4 100644
--- a/openviking/storage/queuefs/embedding_msg_converter.py
+++ b/openviking/storage/queuefs/embedding_msg_converter.py
@@ -8,6 +8,7 @@ to EmbeddingMsg objects for asynchronous vector processing.
"""
from openviking.core.context import Context, ContextLevel
+from openviking.core.namespace import owner_fields_for_uri
from openviking.storage.queuefs.embedding_msg import EmbeddingMsg
from openviking.telemetry import get_current_telemetry
from openviking_cli.utils import get_logger
@@ -33,21 +34,14 @@ class EmbeddingMsgConverter:
if not context_data.get("account_id"):
user = context_data.get("user") or {}
context_data["account_id"] = user.get("account_id", "default")
- if not context_data.get("owner_space"):
- user = context_data.get("user") or {}
- uri = context_data.get("uri", "")
- account = user.get("account_id", "default")
- user_id = user.get("user_id", "default")
- agent_id = user.get("agent_id", "default")
- from openviking_cli.session.user_id import UserIdentifier
-
- owner_user = UserIdentifier(account, user_id, agent_id)
- if uri.startswith("viking://agent/"):
- context_data["owner_space"] = owner_user.agent_space_name()
- elif uri.startswith("viking://user/") or uri.startswith("viking://session/"):
- context_data["owner_space"] = owner_user.user_space_name()
- else:
- context_data["owner_space"] = ""
+ if context_data.get("owner_user_id") is None and context_data.get("owner_agent_id") is None:
+ owner_fields = owner_fields_for_uri(
+ context_data.get("uri", ""),
+ user=context.user,
+ account_id=context_data.get("account_id"),
+ )
+ context_data["owner_user_id"] = owner_fields["owner_user_id"]
+ context_data["owner_agent_id"] = owner_fields["owner_agent_id"]
# Derive level field for hierarchical retrieval.
uri = context_data.get("uri", "")
diff --git a/openviking/storage/queuefs/semantic_processor.py b/openviking/storage/queuefs/semantic_processor.py
index dc1437800..3f4217a3c 100644
--- a/openviking/storage/queuefs/semantic_processor.py
+++ b/openviking/storage/queuefs/semantic_processor.py
@@ -8,6 +8,7 @@ from contextlib import nullcontext
from dataclasses import dataclass, field
from typing import Any, Dict, List, Optional, Set, Tuple
+from openviking.core.namespace import agent_space_fragment, user_space_fragment
from openviking.metrics.account_context import (
bind_metric_account_context,
reset_metric_account_context,
@@ -161,9 +162,9 @@ class SemanticProcessor(DequeueHandlerBase):
caller's space name.
"""
if uri.startswith("viking://agent/"):
- return ctx.user.agent_space_name()
+ return agent_space_fragment(ctx)
if uri.startswith("viking://user/") or uri.startswith("viking://session/"):
- return ctx.user.user_space_name()
+ return user_space_fragment(ctx)
# resources and anything else → shared (empty owner_space)
return ""
diff --git a/openviking/storage/viking_fs.py b/openviking/storage/viking_fs.py
index c6f6bc82f..8429f43c5 100644
--- a/openviking/storage/viking_fs.py
+++ b/openviking/storage/viking_fs.py
@@ -23,13 +23,25 @@ from datetime import datetime
from pathlib import PurePath
from typing import TYPE_CHECKING, Any, Dict, List, Optional, Union
+from openviking.core.namespace import (
+ NamespaceShapeError,
+ canonicalize_uri,
+)
+from openviking.core.namespace import (
+ is_accessible as namespace_is_accessible,
+)
from openviking.pyagfs.exceptions import AGFSClientError, AGFSDirectoryNotEmptyError, AGFSHTTPError
from openviking.resource.watch_storage import is_watch_task_control_uri
from openviking.server.error_mapping import is_not_found_error, map_exception
from openviking.server.identity import RequestContext, Role
from openviking.telemetry import get_current_telemetry
from openviking.utils.time_utils import format_simplified, get_current_timestamp, parse_iso_datetime
-from openviking_cli.exceptions import FailedPreconditionError, NotFoundError
+from openviking_cli.exceptions import (
+ FailedPreconditionError,
+ InvalidArgumentError,
+ NotFoundError,
+ PermissionDeniedError,
+)
from openviking_cli.session.user_id import UserIdentifier
from openviking_cli.utils.logger import get_logger
from openviking_cli.utils.uri import VikingURI
@@ -276,14 +288,19 @@ class VikingFS:
for part in parts:
if part in {".", ".."}:
- raise PermissionError(f"Unsafe URI traversal segment '{part}' in {normalized}")
+ raise PermissionDeniedError(
+ f"Unsafe URI traversal segment '{part}' in {normalized}",
+ resource=normalized,
+ )
if "\\" in part:
- raise PermissionError(
- f"Unsafe URI path separator '\\\\' in component '{part}' of {normalized}"
+ raise PermissionDeniedError(
+ f"Unsafe URI path separator '\\\\' in component '{part}' of {normalized}",
+ resource=normalized,
)
if len(part) >= 2 and part[1] == ":" and part[0].isalpha():
- raise PermissionError(
- f"Unsafe URI drive-prefixed component '{part}' in {normalized}"
+ raise PermissionDeniedError(
+ f"Unsafe URI drive-prefixed component '{part}' in {normalized}",
+ resource=normalized,
)
return normalized, parts
@@ -292,14 +309,17 @@ class VikingFS:
real_ctx = self._ctx_or_default(ctx)
normalized_uri, _ = self._normalized_uri_parts(uri)
if not self._is_accessible(normalized_uri, real_ctx):
- raise PermissionError(f"Access denied for {uri}")
+ raise PermissionDeniedError(f"Access denied for {uri}", resource=normalized_uri)
def _ensure_mutable_access(self, uri: str, ctx: Optional[RequestContext]) -> None:
self._ensure_access(uri, ctx)
real_ctx = self._ctx_or_default(ctx)
normalized_uri, _ = self._normalized_uri_parts(uri)
if real_ctx.role != Role.ROOT and normalized_uri.rstrip("/") == "viking://temp":
- raise PermissionError("Temp root is read-only for non-root users")
+ raise PermissionDeniedError(
+ "Temp root is read-only for non-root users",
+ resource=normalized_uri,
+ )
# ========== AGFS Basic Commands ==========
@@ -1004,6 +1024,10 @@ class VikingFS:
)
if target_uri and target_uri not in {"/", "viking://"}:
+ try:
+ target_uri = canonicalize_uri(target_uri, self._ctx_or_default(ctx))
+ except NamespaceShapeError as exc:
+ raise InvalidArgumentError(str(exc)) from exc
self._ensure_access(target_uri, ctx)
storage = self._get_vector_store()
@@ -1095,6 +1119,16 @@ class VikingFS:
# Normalize target_uri to list
target_uri_list = [target_uri] if isinstance(target_uri, str) else (target_uri or [])
+ real_ctx = self._ctx_or_default(ctx)
+ canonical_target_uri_list: List[str] = []
+ for item in target_uri_list:
+ if not item or item in {"/", "viking://"}:
+ continue
+ try:
+ canonical_target_uri_list.append(canonicalize_uri(item, real_ctx))
+ except NamespaceShapeError as exc:
+ raise InvalidArgumentError(str(exc)) from exc
+ target_uri_list = canonical_target_uri_list
# Use first URI for context inference and access check
primary_target_uri = target_uri_list[0] if target_uri_list else ""
@@ -1306,7 +1340,8 @@ class VikingFS:
"""
real_ctx = self._ctx_or_default(ctx)
account_id = real_ctx.account_id
- _, parts = self._normalized_uri_parts(uri)
+ canonical_uri = canonicalize_uri(uri, real_ctx)
+ _, parts = self._normalized_uri_parts(canonical_uri)
if not parts:
return f"/local/{account_id}"
@@ -1410,16 +1445,7 @@ class VikingFS:
return self._is_legacy_temp_uri_parts(parts)
if scope == "_system":
return False
-
- space = self._extract_space_from_uri(normalized_uri)
- if space is None:
- return True
-
- if scope in {"user", "session"}:
- return space == ctx.user.user_space_name()
- if scope == "agent":
- return space == ctx.user.agent_space_name()
- return True
+ return namespace_is_accessible(normalized_uri, ctx)
def _handle_agfs_read(self, result: Union[bytes, Any, None]) -> bytes:
"""Handle AGFSClient read return types consistently."""
@@ -1822,6 +1848,8 @@ class VikingFS:
existing_bytes = self._handle_agfs_read(self.agfs.read(path))
existing_bytes = await self._decrypt_content(existing_bytes, ctx=ctx)
existing = self._decode_bytes(existing_bytes)
+ except FileNotFoundError:
+ pass
except AGFSHTTPError as e:
if e.status_code != 404:
raise
@@ -1892,19 +1920,22 @@ class VikingFS:
if len(all_entries) >= node_limit:
break
name = entry.get("name", "")
- # After modification: compatible with 7+ digits of microseconds by truncating
raw_time = entry.get("modTime", "")
- if raw_time and len(raw_time) > 26 and "+" in raw_time:
- # Handle strings like 2026-02-21T13:20:23.1470042+08:00
- # Truncate to 2026-02-21T13:20:23.147004+08:00
- parts = raw_time.split("+")
- # Keep time part at most 26 characters (YYYY-MM-DDTHH:MM:SS.mmmmmm)
- raw_time = parts[0][:26] + "+" + parts[1]
+ parsed_time = now
+ if isinstance(raw_time, (int, float)):
+ parsed_time = datetime.fromtimestamp(raw_time)
+ elif raw_time:
+ if len(raw_time) > 26 and "+" in raw_time:
+ parts = raw_time.split("+")
+ raw_time = parts[0][:26] + "+" + parts[1]
+ parsed_time = parse_iso_datetime(raw_time)
+ elif isinstance(entry.get("mtime"), (int, float)):
+ parsed_time = datetime.fromtimestamp(entry["mtime"])
new_entry = {
"uri": self._path_to_uri(f"{path}/{name}", ctx=ctx),
"size": entry.get("size", 0),
"isDir": entry.get("isDir", False),
- "modTime": format_simplified(parse_iso_datetime(raw_time), now),
+ "modTime": format_simplified(parsed_time, now),
}
if not self._is_accessible(new_entry["uri"], real_ctx):
continue
diff --git a/openviking/storage/viking_vector_index_backend.py b/openviking/storage/viking_vector_index_backend.py
index adaf3a1df..52b3a4e42 100644
--- a/openviking/storage/viking_vector_index_backend.py
+++ b/openviking/storage/viking_vector_index_backend.py
@@ -7,6 +7,7 @@ from __future__ import annotations
import uuid
from typing import Any, Dict, List, Optional
+from openviking.core.namespace import canonicalize_uri, visible_roots
from openviking.server.identity import RequestContext, Role
from openviking.storage.expr import And, Eq, FilterExpr, In, Or, PathScope, RawDSL
from openviking.storage.vectordb.collection.collection import Collection
@@ -41,7 +42,8 @@ MEMORY_DEDUP_OUTPUT_FIELDS = [
"active_count",
"level",
"account_id",
- "owner_space",
+ "owner_user_id",
+ "owner_agent_id",
]
FETCH_BY_URI_OUTPUT_FIELDS = [
@@ -57,7 +59,8 @@ FETCH_BY_URI_OUTPUT_FIELDS = [
"tags",
"abstract",
"account_id",
- "owner_space",
+ "owner_user_id",
+ "owner_agent_id",
]
URI_REWRITE_OUTPUT_FIELDS = [
@@ -75,7 +78,8 @@ URI_REWRITE_OUTPUT_FIELDS = [
"tags",
"abstract",
"account_id",
- "owner_space",
+ "owner_user_id",
+ "owner_agent_id",
]
@@ -851,9 +855,9 @@ class VikingVectorIndexBackend:
limit: int = 10,
) -> List[Dict[str, Any]]:
# TODO:Better Alternative to Current Temporary Fix
-
- # If parent_uri is already under the requested target_directories,
- # adding a redundant scope prefix filter can slow down the backend.
+
+ # If parent_uri is already under the requested target_directories,
+ # adding a redundant scope prefix filter can slow down the backend.
# Keep tenant/context filters but skip target_directories in that case.
effective_target_directories = target_directories
if target_directories:
@@ -898,10 +902,8 @@ class VikingVectorIndexBackend:
Eq("level", 2),
Eq("account_id", ctx.account_id),
]
- if owner_space:
- conds.append(Eq("owner_space", owner_space))
if category_uri_prefix:
- conds.append(In("uri", [category_uri_prefix]))
+ conds.append(PathScope("uri", canonicalize_uri(category_uri_prefix, ctx), depth=-1))
backend = self._get_backend_for_context(ctx)
return await backend.search(
@@ -920,9 +922,10 @@ class VikingVectorIndexBackend:
*,
ctx: RequestContext,
) -> List[Dict[str, Any]]:
- conds: List[FilterExpr] = [PathScope("uri", uri, depth=0), Eq("account_id", ctx.account_id)]
- if owner_space:
- conds.append(Eq("owner_space", owner_space))
+ conds: List[FilterExpr] = [
+ PathScope("uri", canonicalize_uri(uri, ctx), depth=0),
+ Eq("account_id", ctx.account_id),
+ ]
if level is not None:
conds.append(Eq("level", level))
@@ -941,17 +944,11 @@ class VikingVectorIndexBackend:
async def delete_uris(self, ctx: RequestContext, uris: List[str]) -> None:
for uri in uris:
+ canonical_uri = canonicalize_uri(uri, ctx)
conds: List[FilterExpr] = [
Eq("account_id", ctx.account_id),
- Or([Eq("uri", uri), In("uri", [f"{uri}/"])]),
+ Or([Eq("uri", canonical_uri), In("uri", [f"{canonical_uri}/"])]),
]
- if ctx.role == Role.USER and uri.startswith(("viking://user/", "viking://agent/")):
- owner_space = (
- ctx.user.user_space_name()
- if uri.startswith("viking://user/")
- else ctx.user.agent_space_name()
- )
- conds.append(Eq("owner_space", owner_space))
backend = self._get_backend_for_context(ctx)
await backend.delete_by_filter(And(conds))
@@ -965,16 +962,11 @@ class VikingVectorIndexBackend:
) -> bool:
import hashlib
- conds: List[FilterExpr] = [Eq("uri", uri), Eq("account_id", ctx.account_id)]
+ canonical_uri = canonicalize_uri(uri, ctx)
+ canonical_new_uri = canonicalize_uri(new_uri, ctx)
+ conds: List[FilterExpr] = [Eq("uri", canonical_uri), Eq("account_id", ctx.account_id)]
if levels:
conds.append(In("level", levels))
- if ctx.role == Role.USER and uri.startswith(("viking://user/", "viking://agent/")):
- owner_space = (
- ctx.user.user_space_name()
- if uri.startswith("viking://user/")
- else ctx.user.agent_space_name()
- )
- conds.append(Eq("owner_space", owner_space))
records = await self.filter(
filter=And(conds),
@@ -1003,14 +995,14 @@ class VikingVectorIndexBackend:
except (TypeError, ValueError):
level = 2
- seed_uri = _seed_uri_for_id(new_uri, level)
+ seed_uri = _seed_uri_for_id(canonical_new_uri, level)
id_seed = f"{ctx.account_id}:{seed_uri}"
new_id = hashlib.md5(id_seed.encode("utf-8")).hexdigest()
updated = {
**record,
"id": new_id,
- "uri": new_uri,
+ "uri": canonical_new_uri,
}
if await self.upsert(updated, ctx=ctx):
success = True
@@ -1061,7 +1053,7 @@ class VikingVectorIndexBackend:
if target_directories:
uri_conds = [
- PathScope("uri", target_dir, depth=-1)
+ PathScope("uri", canonicalize_uri(target_dir, ctx), depth=-1)
for target_dir in target_directories
if target_dir
]
@@ -1084,31 +1076,11 @@ class VikingVectorIndexBackend:
if ctx.role == Role.ROOT:
return None
- user_spaces = [ctx.user.user_space_name(), ctx.user.agent_space_name()]
- resource_spaces = [*user_spaces, ""]
account_filter = Eq("account_id", ctx.account_id)
-
- if context_type == "resource":
- return And([account_filter, In("owner_space", resource_spaces)])
- if context_type in {"memory", "skill"}:
- return And([account_filter, In("owner_space", user_spaces)])
-
- return And(
- [
- account_filter,
- Or(
- [
- And([Eq("context_type", "resource"), In("owner_space", resource_spaces)]),
- And(
- [
- In("context_type", ["memory", "skill"]),
- In("owner_space", user_spaces),
- ]
- ),
- ]
- ),
- ]
- )
+ path_filter = Or([PathScope("uri", root, depth=-1) for root in visible_roots(ctx)])
+ if context_type:
+ return And([account_filter, path_filter])
+ return And([account_filter, path_filter])
@staticmethod
def _merge_filters(*filters: Optional[FilterExpr]) -> Optional[FilterExpr]:
diff --git a/openviking/sync_client.py b/openviking/sync_client.py
index 48efaadb6..c12f8578c 100644
--- a/openviking/sync_client.py
+++ b/openviking/sync_client.py
@@ -77,6 +77,7 @@ class SyncOpenViking:
content: str | None = None,
parts: list[dict] | None = None,
created_at: str | None = None,
+ role_id: str | None = None,
) -> Dict[str, Any]:
"""Add a message to a session.
@@ -86,11 +87,12 @@ class SyncOpenViking:
content: Text content (simple mode)
parts: Parts array (full Part support: TextPart, ContextPart, ToolPart)
created_at: Message creation time (ISO format string). If not provided, current time is used.
+ role_id: Optional explicit actor identity. Omit to let the client/server derive it.
If both content and parts are provided, parts takes precedence.
"""
return run_async(
- self._async_client.add_message(session_id, role, content, parts, created_at)
+ self._async_client.add_message(session_id, role, content, parts, created_at, role_id)
)
def commit_session(
diff --git a/openviking/utils/embedding_utils.py b/openviking/utils/embedding_utils.py
index ef9151e0b..e0e23ca1b 100644
--- a/openviking/utils/embedding_utils.py
+++ b/openviking/utils/embedding_utils.py
@@ -12,6 +12,7 @@ from typing import Dict, Optional
from openviking.core.context import Context, ContextLevel, ResourceContentType, Vectorize
from openviking.core.directories import get_context_type_for_uri
+from openviking.core.namespace import agent_space_fragment, user_space_fragment
from openviking.server.identity import RequestContext
from openviking.storage.queuefs import get_queue_manager
from openviking.storage.queuefs.embedding_msg_converter import EmbeddingMsgConverter
@@ -42,9 +43,9 @@ async def _decrement_embedding_tracker(semantic_msg_id: Optional[str], count: in
def _owner_space_for_uri(uri: str, ctx: RequestContext) -> str:
"""Derive owner_space from a URI."""
if uri.startswith("viking://agent/"):
- return ctx.user.agent_space_name()
+ return agent_space_fragment(ctx)
if uri.startswith("viking://user/") or uri.startswith("viking://session/"):
- return ctx.user.user_space_name()
+ return user_space_fragment(ctx)
return ""
diff --git a/openviking/utils/skill_processor.py b/openviking/utils/skill_processor.py
index 458608ca2..665dda829 100644
--- a/openviking/utils/skill_processor.py
+++ b/openviking/utils/skill_processor.py
@@ -14,6 +14,7 @@ from typing import Any, Dict, List, Optional
from openviking.core.context import Context, ContextType, Vectorize
from openviking.core.mcp_converter import is_mcp_format, mcp_to_skill
+from openviking.core.namespace import agent_space_fragment, canonical_agent_root
from openviking.core.skill_loader import SkillLoader
from openviking.server.identity import RequestContext
from openviking.server.local_input_guard import deny_direct_local_skill_input
@@ -80,14 +81,14 @@ class SkillProcessor:
)
context = Context(
- uri=f"viking://agent/skills/{skill_dict['name']}",
- parent_uri="viking://agent/skills",
+ uri=f"{canonical_agent_root(ctx)}/skills/{skill_dict['name']}",
+ parent_uri=f"{canonical_agent_root(ctx)}/skills",
is_leaf=False,
abstract=skill_dict.get("description", ""),
context_type=ContextType.SKILL.value,
user=ctx.user,
account_id=ctx.account_id,
- owner_space=ctx.user.agent_space_name(),
+ owner_space=agent_space_fragment(ctx),
meta={
"name": skill_dict["name"],
"description": skill_dict.get("description", ""),
diff --git a/openviking_cli/client/base.py b/openviking_cli/client/base.py
index 51abb0c8e..e06fb826e 100644
--- a/openviking_cli/client/base.py
+++ b/openviking_cli/client/base.py
@@ -263,6 +263,7 @@ class BaseClient(ABC):
content: str | None = None,
parts: list[dict] | None = None,
created_at: str | None = None,
+ role_id: str | None = None,
) -> Dict[str, Any]:
"""Add a message to a session.
@@ -272,6 +273,7 @@ class BaseClient(ABC):
content: Text content (simple mode)
parts: Parts array (full Part support: TextPart, ContextPart, ToolPart)
created_at: Message creation time (ISO format string)
+ role_id: Optional explicit actor identity. Omit to let the server derive it.
If both content and parts are provided, parts takes precedence.
"""
diff --git a/openviking_cli/client/http.py b/openviking_cli/client/http.py
index 198b50f2b..86e23468b 100644
--- a/openviking_cli/client/http.py
+++ b/openviking_cli/client/http.py
@@ -801,6 +801,7 @@ class AsyncHTTPClient(BaseClient):
content: str | None = None,
parts: list[dict] | None = None,
created_at: str | None = None,
+ role_id: str | None = None,
) -> Dict[str, Any]:
"""Add a message to a session.
@@ -810,6 +811,7 @@ class AsyncHTTPClient(BaseClient):
content: Text content (simple mode, backward compatible)
parts: Parts array (full Part support mode)
created_at: Message creation time (ISO format string)
+ role_id: Optional explicit actor identity. Omit to let the server derive it.
If both content and parts are provided, parts takes precedence.
"""
@@ -823,6 +825,8 @@ class AsyncHTTPClient(BaseClient):
if created_at is not None:
payload["created_at"] = created_at
+ if role_id is not None:
+ payload["role_id"] = role_id
response = await self._http.post(
f"/api/v1/sessions/{session_id}/messages",
diff --git a/openviking_cli/client/sync_http.py b/openviking_cli/client/sync_http.py
index 2da8c2d8b..1e3cd3a92 100644
--- a/openviking_cli/client/sync_http.py
+++ b/openviking_cli/client/sync_http.py
@@ -114,6 +114,7 @@ class SyncHTTPClient:
content: str | None = None,
parts: list[dict] | None = None,
created_at: str | None = None,
+ role_id: str | None = None,
) -> Dict[str, Any]:
"""Add a message to a session.
@@ -123,11 +124,12 @@ class SyncHTTPClient:
content: Text content (simple mode)
parts: Parts array (full Part support: TextPart, ContextPart, ToolPart)
created_at: Message creation time (ISO format string)
+ role_id: Optional explicit actor identity. Omit to let the server derive it.
If both content and parts are provided, parts takes precedence.
"""
return run_async(
- self._async_client.add_message(session_id, role, content, parts, created_at)
+ self._async_client.add_message(session_id, role, content, parts, created_at, role_id)
)
def get_task(self, task_id: str) -> Optional[Dict[str, Any]]:
diff --git a/openviking_cli/session/user_id.py b/openviking_cli/session/user_id.py
index 5d221a6d3..04ce3fb8b 100644
--- a/openviking_cli/session/user_id.py
+++ b/openviking_cli/session/user_id.py
@@ -50,22 +50,18 @@ class UserIdentifier(object):
return self._user_id
def _agent_space_source(self) -> str:
- """Return the source string used to derive the agent-level space."""
- scope_mode = "user+agent"
- try:
- from openviking_cli.utils.config import get_openviking_config
-
- scope_mode = get_openviking_config().memory.agent_scope_mode
- except Exception:
- # Fall back to the legacy, fully isolated behavior when config is unavailable.
- scope_mode = "user+agent"
-
- if scope_mode == "agent":
- return self._agent_id
+ """Return the legacy source string used by deprecated hash-based agent helpers.
+
+ This helper is kept only for backward-compatible tooling paths. Service-side
+ namespace resolution is now driven by per-account namespace policy instead.
+ """
return f"{self._user_id}:{self._agent_id}"
def agent_space_name(self) -> str:
- """Agent-level space name derived from memory.agent_scope_mode."""
+ """Return the legacy hash-based agent space for backward-compatible helpers only.
+
+ New server-side agent URIs no longer derive from this hash helper.
+ """
return hashlib.md5(self._agent_space_source().encode()).hexdigest()[:12]
def memory_space_uri(self) -> str:
diff --git a/openviking_cli/utils/config/memory_config.py b/openviking_cli/utils/config/memory_config.py
index 075376906..7157913d6 100644
--- a/openviking_cli/utils/config/memory_config.py
+++ b/openviking_cli/utils/config/memory_config.py
@@ -15,8 +15,8 @@ class MemoryConfig(BaseModel):
agent_scope_mode: str = Field(
default="user+agent",
description=(
- "Agent memory namespace mode: 'user+agent' keeps agent memory isolated by "
- "(user_id, agent_id), while 'agent' shares agent memory across users of the same agent."
+ "Deprecated and ignored. Kept only for backward compatibility with older ov.conf files. "
+ "Agent/user namespace behavior is now controlled by per-account namespace policy."
),
)
diff --git a/openviking_cli/utils/config/open_viking_config.py b/openviking_cli/utils/config/open_viking_config.py
index 050b6d5e3..035c33e3c 100644
--- a/openviking_cli/utils/config/open_viking_config.py
+++ b/openviking_cli/utils/config/open_viking_config.py
@@ -1,6 +1,7 @@
# Copyright (c) 2026 Beijing Volcano Engine Technology Co., Ltd.
# SPDX-License-Identifier: AGPL-3.0
import json
+import logging
import os
from pathlib import Path
from threading import Lock
@@ -228,6 +229,15 @@ class OpenVikingConfig(BaseModel):
# Apply memory configuration
if memory_config_data is not None:
+ if (
+ isinstance(memory_config_data, dict)
+ and "agent_scope_mode" in memory_config_data
+ ):
+ logging.getLogger(__name__).warning(
+ "memory.agent_scope_mode is deprecated and ignored. "
+ "User/agent namespace behavior is now controlled by per-account "
+ "namespace policy."
+ )
instance.memory = MemoryConfig.from_dict(memory_config_data)
# Apply parser configurations
@@ -245,8 +255,6 @@ class OpenVikingConfig(BaseModel):
db_dim = instance.storage.vectordb.dimension
emb_dim = instance.embedding.dimension
if db_dim > 0 and emb_dim > 0 and db_dim != emb_dim:
- import logging
-
logging.warning(
f"Dimension mismatch: VectorDB dimension is {db_dim}, "
f"but Embedding dimension is {emb_dim}. "
@@ -336,9 +344,7 @@ class OpenVikingConfigSingleton:
if config_dict is not None:
cls._instance = OpenVikingConfig.from_dict(config_dict)
else:
- path = resolve_config_path(
- config_path, OPENVIKING_CONFIG_ENV, DEFAULT_OV_CONF
- )
+ path = resolve_config_path(config_path, OPENVIKING_CONFIG_ENV, DEFAULT_OV_CONF)
if path is not None:
cls._instance = cls._load_from_file(str(path))
else:
diff --git a/tests/api_test/api/client.py b/tests/api_test/api/client.py
index 4fbfd12cf..30cf2ca5a 100644
--- a/tests/api_test/api/client.py
+++ b/tests/api_test/api/client.py
@@ -19,12 +19,14 @@ class OpenVikingAPIClient:
api_key: Optional[str] = None,
account: Optional[str] = None,
user: Optional[str] = None,
+ agent: Optional[str] = None,
):
self.base_url = base_url or Config.CONSOLE_URL
self.server_url = server_url or Config.SERVER_URL
self.api_key = api_key or Config.OPENVIKING_API_KEY
self.account = account or Config.OPENVIKING_ACCOUNT
self.user = user or Config.OPENVIKING_USER
+ self.agent = agent or Config.OPENVIKING_AGENT
self.session = requests.Session()
self._setup_default_headers()
self.max_retries = 3
@@ -108,6 +110,7 @@ class OpenVikingAPIClient:
"User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36",
"X-OpenViking-Account": self.account,
"X-OpenViking-User": self.user,
+ "X-OpenViking-Agent": self.agent,
}
if self.api_key:
headers["Authorization"] = f"Bearer {self.api_key}"
@@ -312,10 +315,19 @@ class OpenVikingAPIClient:
url = self._build_url(self.server_url, endpoint)
return self._request_with_retry("DELETE", url)
- def add_message(self, session_id: str, role: str, content: str) -> requests.Response:
+ def add_message(
+ self,
+ session_id: str,
+ role: str,
+ content: str,
+ role_id: Optional[str] = None,
+ ) -> requests.Response:
endpoint = f"/api/v1/sessions/{session_id}/messages"
url = self._build_url(self.server_url, endpoint)
- return self._request_with_retry("POST", url, json={"role": role, "content": content})
+ payload = {"role": role, "content": content}
+ if role_id is not None:
+ payload["role_id"] = role_id
+ return self._request_with_retry("POST", url, json=payload)
def fs_ls(self, uri: str, simple: bool = False, recursive: bool = False) -> requests.Response:
endpoint = "/api/v1/fs/ls"
diff --git a/tests/api_test/tools/config/config.py b/tests/api_test/tools/config/config.py
index 86ba8d317..e21417a76 100644
--- a/tests/api_test/tools/config/config.py
+++ b/tests/api_test/tools/config/config.py
@@ -13,6 +13,7 @@ class Config:
OPENVIKING_API_KEY = os.getenv("OPENVIKING_API_KEY", "test-root-api-key")
OPENVIKING_ACCOUNT = os.getenv("OPENVIKING_ACCOUNT", "default")
OPENVIKING_USER = os.getenv("OPENVIKING_USER", "default")
+ OPENVIKING_AGENT = os.getenv("OPENVIKING_AGENT", "default")
SERVER_STARTUP_TIMEOUT = 30
CONSOLE_STARTUP_TIMEOUT = 30
diff --git a/tests/cli/test_user_identifier.py b/tests/cli/test_user_identifier.py
index dfddcf2bc..90049f7cc 100644
--- a/tests/cli/test_user_identifier.py
+++ b/tests/cli/test_user_identifier.py
@@ -1,10 +1,7 @@
"""Tests for UserIdentifier, specifically agent_space_name collision safety."""
from openviking_cli.session.user_id import UserIdentifier
-from openviking_cli.utils.config import (
- OpenVikingConfigSingleton,
- get_openviking_config,
-)
+from openviking_cli.utils.config import OpenVikingConfigSingleton
class TestAgentSpaceNameCollision:
@@ -35,23 +32,10 @@ class TestAgentSpaceNameCollision:
assert len(name) == 12
assert all(c in "0123456789abcdef" for c in name)
- def test_agent_scope_mode_agent_shares_across_users(self):
- """When memory.agent_scope_mode=agent, users of the same agent share the same space."""
+ def test_agent_scope_mode_is_ignored(self):
+ """Deprecated memory.agent_scope_mode no longer changes agent_space_name."""
OpenVikingConfigSingleton.reset_instance()
- config = get_openviking_config()
- config.memory.agent_scope_mode = "agent"
-
- u1 = UserIdentifier("acct", "alice", "bot")
- u2 = UserIdentifier("acct", "bob", "bot")
- assert u1.agent_space_name() == u2.agent_space_name()
-
- OpenVikingConfigSingleton.reset_instance()
-
- def test_agent_scope_mode_user_and_agent_keeps_user_isolation(self):
- """When memory.agent_scope_mode=user+agent, different users remain isolated."""
- OpenVikingConfigSingleton.reset_instance()
- config = get_openviking_config()
- config.memory.agent_scope_mode = "user+agent"
+ OpenVikingConfigSingleton.initialize(config_dict={"memory": {"agent_scope_mode": "agent"}})
u1 = UserIdentifier("acct", "alice", "bot")
u2 = UserIdentifier("acct", "bob", "bot")
diff --git a/tests/integration/test_compressor_v2_e2e.py b/tests/integration/test_compressor_v2_e2e.py
index e5a71598f..43d82b957 100644
--- a/tests/integration/test_compressor_v2_e2e.py
+++ b/tests/integration/test_compressor_v2_e2e.py
@@ -198,30 +198,25 @@ class TestCompressorV2EndToEnd:
except Exception as e:
print(f" Failed to read {uri}: {e}")
- user_space = client._user.user_space_name()
- agent_space = client._user.agent_space_name()
-
try:
# Try to list agent memories
- agent_memories = await client.ls(
- f"viking://agent/{agent_space}/memories", recursive=True
- )
+ agent_memories = await client.ls("viking://agent/memories", recursive=True)
print(f"Agent memories entries: {len(agent_memories)}")
for entry in agent_memories[:20]: # Show first 20
print(f" - {entry['name']} ({'dir' if entry['isDir'] else 'file'})")
# Read and print memory files
- await print_memory_files(f"viking://agent/{agent_space}/memories", agent_memories)
+ await print_memory_files("viking://agent/memories", agent_memories)
except Exception as e:
print(f"Could not list agent memories: {e}")
try:
# Try to list user memories
- user_memories = await client.ls(f"viking://user/{user_space}/memories", recursive=True)
+ user_memories = await client.ls("viking://user/memories", recursive=True)
print(f"\nUser memories entries: {len(user_memories)}")
for entry in user_memories[:20]: # Show first 20
print(f" - {entry['name']} ({'dir' if entry['isDir'] else 'file'})")
# Read and print memory files
- await print_memory_files(f"viking://user/{user_space}/memories", user_memories)
+ await print_memory_files("viking://user/memories", user_memories)
except Exception as e:
print(f"Could not list user memories: {e}")
diff --git a/tests/server/test_api_key_manager.py b/tests/server/test_api_key_manager.py
index 1055dd938..85eed2136 100644
--- a/tests/server/test_api_key_manager.py
+++ b/tests/server/test_api_key_manager.py
@@ -9,7 +9,7 @@ import pytest
import pytest_asyncio
from openviking.server.api_keys import APIKeyManager
-from openviking.server.identity import Role
+from openviking.server.identity import AccountNamespacePolicy, Role
from openviking.service.core import OpenVikingService
from openviking_cli.exceptions import AlreadyExistsError, NotFoundError, UnauthenticatedError
from openviking_cli.session.user_id import UserIdentifier
@@ -111,6 +111,7 @@ async def test_default_account_exists(manager: APIKeyManager):
"""Default account should be created on load."""
accounts = manager.get_accounts()
assert any(a["account_id"] == "default" for a in accounts)
+ assert manager.get_account_policy("default") == AccountNamespacePolicy()
# ---- User lifecycle tests ----
@@ -223,6 +224,40 @@ async def test_persistence_across_reload(manager_service):
assert identity.role == Role.ADMIN
+async def test_legacy_account_without_settings_infers_user_and_agent_policy(manager_service):
+ """Legacy accounts default to user-shared + agent-shared and persist the inferred policy."""
+ acct = _uid()
+ created_at = "2026-04-16T00:00:00+00:00"
+
+ seed_mgr = APIKeyManager(root_key=ROOT_KEY, viking_fs=manager_service.viking_fs)
+ await seed_mgr._write_json(
+ "/local/_system/accounts.json", {"accounts": {acct: {"created_at": created_at}}}
+ )
+ await seed_mgr._write_json(
+ f"/local/{acct}/_system/users.json",
+ {"users": {"alice": {"role": "admin", "key": "legacy-key-alice"}}},
+ )
+
+ mgr = APIKeyManager(
+ root_key=ROOT_KEY,
+ viking_fs=manager_service.viking_fs,
+ )
+ await mgr.load()
+
+ assert mgr.get_account_policy(acct) == AccountNamespacePolicy(
+ isolate_user_scope_by_agent=False,
+ isolate_agent_scope_by_user=False,
+ )
+
+ settings = await mgr._read_json(f"/local/{acct}/_system/setting.json")
+ assert settings == {
+ "namespace": {
+ "isolate_user_scope_by_agent": False,
+ "isolate_agent_scope_by_user": False,
+ }
+ }
+
+
# ---- Encryption tests ----
diff --git a/tests/server/test_api_search.py b/tests/server/test_api_search.py
index f3f376468..80453252c 100644
--- a/tests/server/test_api_search.py
+++ b/tests/server/test_api_search.py
@@ -9,7 +9,10 @@ import httpx
import pytest
from openviking.models.embedder.base import EmbedResult
+from openviking.server.auth import get_request_context
+from openviking.server.identity import RequestContext, Role
from openviking.utils.time_utils import parse_iso_datetime
+from openviking_cli.session.user_id import UserIdentifier
@pytest.fixture(autouse=True)
@@ -45,6 +48,28 @@ async def test_find_with_target_uri(client_with_resource):
assert resp.json()["status"] == "ok"
+async def test_find_with_inaccessible_target_uri_returns_permission_denied(
+ client: httpx.AsyncClient, app
+):
+ app.dependency_overrides[get_request_context] = lambda: RequestContext(
+ user=UserIdentifier.the_default_user(),
+ role=Role.USER,
+ )
+ try:
+ resp = await client.post(
+ "/api/v1/search/find",
+ json={"query": "sample", "target_uri": "viking://agent/foreign-agent", "limit": 5},
+ )
+ finally:
+ app.dependency_overrides.pop(get_request_context, None)
+
+ assert resp.status_code == 403
+ body = resp.json()
+ assert body["status"] == "error"
+ assert body["error"]["code"] == "PERMISSION_DENIED"
+ assert "Access denied" in body["error"]["message"]
+
+
async def test_find_with_score_threshold(client_with_resource):
client, uri = client_with_resource
resp = await client.post(
diff --git a/tests/server/test_api_sessions.py b/tests/server/test_api_sessions.py
index d4070b463..05a8d9380 100644
--- a/tests/server/test_api_sessions.py
+++ b/tests/server/test_api_sessions.py
@@ -9,14 +9,45 @@ from unittest.mock import patch
import httpx
import pytest
+from fastapi import FastAPI
+from starlette.requests import Request
from openviking.message import Message
+from openviking.server.api_keys import APIKeyManager
+from openviking.server.config import ServerConfig
from openviking.server.identity import RequestContext, Role
+from openviking.server.routers import sessions as sessions_router
+from openviking_cli.exceptions import InvalidArgumentError
from openviking_cli.session.user_id import UserIdentifier
from openviking_cli.utils.config import OPENVIKING_CONFIG_ENV
from openviking_cli.utils.config.open_viking_config import OpenVikingConfigSingleton
from tests.utils.mock_agfs import MockLocalAGFS
+DEFAULT_USER = UserIdentifier.the_default_user()
+TEST_ROOT_KEY = "root-secret-key-for-session-tests"
+_UNSET = object()
+
+
+def _message_request(
+ role: str,
+ *,
+ content: str | None = None,
+ parts: list[dict] | None = None,
+ role_id: object = _UNSET,
+) -> dict:
+ payload = {"role": role}
+ if content is not None:
+ payload["content"] = content
+ if parts is not None:
+ payload["parts"] = parts
+ if role_id is _UNSET and role == "user":
+ payload["role_id"] = DEFAULT_USER.user_id
+ elif role_id is _UNSET and role == "assistant":
+ payload["role_id"] = DEFAULT_USER.agent_id
+ elif role_id is not None:
+ payload["role_id"] = role_id
+ return payload
+
@pytest.fixture(autouse=True)
def _configure_test_env(monkeypatch, tmp_path):
@@ -65,6 +96,45 @@ async def _wait_for_task(client: httpx.AsyncClient, task_id: str, timeout: float
raise TimeoutError(f"Task {task_id} did not complete within {timeout}s")
+def _session_route_request(
+ *,
+ auth_mode: str = "api_key",
+ api_key_manager=None,
+) -> Request:
+ app = FastAPI()
+ app.state.config = ServerConfig(auth_mode=auth_mode)
+ app.state.api_key_manager = api_key_manager
+ scope = {
+ "type": "http",
+ "path": "/api/v1/sessions/test-session/messages",
+ "headers": [],
+ "app": app,
+ }
+ return Request(scope)
+
+
+async def _call_add_message_route(
+ service,
+ monkeypatch,
+ *,
+ ctx: RequestContext,
+ payload: dict,
+ auth_mode: str = "api_key",
+ api_key_manager=None,
+ session_id: str = "test-session",
+):
+ monkeypatch.setattr(sessions_router, "get_service", lambda: service)
+ return await sessions_router.add_message(
+ request=sessions_router.AddMessageRequest.model_validate(payload),
+ http_request=_session_route_request(
+ auth_mode=auth_mode,
+ api_key_manager=api_key_manager,
+ ),
+ session_id=session_id,
+ _ctx=ctx,
+ )
+
+
async def test_create_session(client: httpx.AsyncClient):
resp = await client.post("/api/v1/sessions", json={})
assert resp.status_code == 200
@@ -100,7 +170,7 @@ async def test_get_session_context(client: httpx.AsyncClient):
await client.post(
f"/api/v1/sessions/{session_id}/messages",
- json={"role": "user", "content": "Current live message"},
+ json=_message_request("user", content="Current live message"),
)
resp = await client.get(f"/api/v1/sessions/{session_id}/context")
@@ -120,7 +190,7 @@ async def test_get_session_context_includes_incomplete_archive_messages(
await client.post(
f"/api/v1/sessions/{session_id}/messages",
- json={"role": "user", "content": "Archived seed"},
+ json=_message_request("user", content="Archived seed"),
)
commit_resp = await client.post(f"/api/v1/sessions/{session_id}/commit")
assert commit_resp.status_code == 200
@@ -129,8 +199,11 @@ async def test_get_session_context_includes_incomplete_archive_messages(
session = service.sessions.session(ctx, session_id)
await session.load()
pending_messages = [
- Message.create_user("Pending user message"),
- Message.create_assistant("Pending assistant response"),
+ Message.create_user("Pending user message", role_id=DEFAULT_USER.user_id),
+ Message.create_assistant(
+ "Pending assistant response",
+ role_id=DEFAULT_USER.agent_id,
+ ),
]
await session._viking_fs.write_file(
uri=f"{session.uri}/history/archive_002/messages.jsonl",
@@ -140,7 +213,7 @@ async def test_get_session_context_includes_incomplete_archive_messages(
await client.post(
f"/api/v1/sessions/{session_id}/messages",
- json={"role": "user", "content": "Current live message"},
+ json=_message_request("user", content="Current live message"),
)
resp = await client.get(f"/api/v1/sessions/{session_id}/context")
@@ -159,7 +232,7 @@ async def test_add_message(client: httpx.AsyncClient):
resp = await client.post(
f"/api/v1/sessions/{session_id}/messages",
- json={"role": "user", "content": "Hello, world!"},
+ json=_message_request("user", content="Hello, world!"),
)
assert resp.status_code == 200
body = resp.json()
@@ -167,6 +240,133 @@ async def test_add_message(client: httpx.AsyncClient):
assert body["result"]["message_count"] == 1
+async def test_add_message_root_request_autofills_role_id(service, monkeypatch):
+ session_id = "root-auto-fill"
+ ctx = RequestContext(user=DEFAULT_USER, role=Role.ROOT)
+
+ response = await _call_add_message_route(
+ service,
+ monkeypatch,
+ ctx=ctx,
+ payload=_message_request("user", content="hello root", role_id=None),
+ session_id=session_id,
+ )
+
+ assert response.result["message_count"] == 1
+ session = await service.sessions.get(session_id, ctx, auto_create=False)
+ await session.load()
+ assert session.messages[-1].role_id == DEFAULT_USER.user_id
+
+
+async def test_add_message_trusted_request_allows_explicit_role_id(service, monkeypatch):
+ session_id = "trusted-explicit-role-id"
+ ctx = RequestContext(
+ user=UserIdentifier("acct_trusted", "caller", "assistant-a"),
+ role=Role.USER,
+ )
+
+ response = await _call_add_message_route(
+ service,
+ monkeypatch,
+ ctx=ctx,
+ payload=_message_request("assistant", content="hello trusted", role_id="assistant-b"),
+ auth_mode="trusted",
+ session_id=session_id,
+ )
+
+ assert response.result["message_count"] == 1
+ session = await service.sessions.get(session_id, ctx, auto_create=False)
+ await session.load()
+ assert session.messages[-1].role_id == "assistant-b"
+
+
+async def test_add_message_admin_request_allows_registered_user_role_id(service, monkeypatch):
+ manager = APIKeyManager(root_key=TEST_ROOT_KEY, viking_fs=service.viking_fs)
+ await manager.load()
+ account_id = "acct_session_admin"
+ await manager.create_account(account_id, "admin_user")
+ await manager.register_user(account_id, "alice")
+
+ ctx = RequestContext(
+ user=UserIdentifier(account_id, "admin_user", "assistant-admin"),
+ role=Role.ADMIN,
+ )
+ session_id = "admin-explicit-role-id"
+
+ response = await _call_add_message_route(
+ service,
+ monkeypatch,
+ ctx=ctx,
+ payload=_message_request("user", content="hello admin", role_id="alice"),
+ api_key_manager=manager,
+ session_id=session_id,
+ )
+
+ assert response.result["message_count"] == 1
+ session = await service.sessions.get(session_id, ctx, auto_create=False)
+ await session.load()
+ assert session.messages[-1].role_id == "alice"
+
+
+async def test_add_message_user_request_rejects_explicit_role_id(service, monkeypatch):
+ ctx = RequestContext(
+ user=UserIdentifier("acct_session_user", "alice", "assistant-user"),
+ role=Role.USER,
+ )
+
+ with pytest.raises(InvalidArgumentError, match="cannot explicitly set role_id"):
+ await _call_add_message_route(
+ service,
+ monkeypatch,
+ ctx=ctx,
+ payload=_message_request("user", content="hello user", role_id="alice"),
+ session_id="user-explicit-role-id",
+ )
+
+
+async def test_add_message_user_request_autofills_role_id(service, monkeypatch):
+ session_id = "user-auto-fill-role-id"
+ ctx = RequestContext(
+ user=UserIdentifier("acct_session_user", "alice", "assistant-user"),
+ role=Role.USER,
+ )
+
+ response = await _call_add_message_route(
+ service,
+ monkeypatch,
+ ctx=ctx,
+ payload=_message_request("assistant", content="hello user", role_id=None),
+ session_id=session_id,
+ )
+
+ assert response.result["message_count"] == 1
+ session = await service.sessions.get(session_id, ctx, auto_create=False)
+ await session.load()
+ assert session.messages[-1].role_id == "assistant-user"
+
+
+async def test_add_message_rejects_unregistered_user_role_id(service, monkeypatch):
+ manager = APIKeyManager(root_key=TEST_ROOT_KEY, viking_fs=service.viking_fs)
+ await manager.load()
+ account_id = "acct_session_invalid"
+ await manager.create_account(account_id, "admin_user")
+
+ ctx = RequestContext(
+ user=UserIdentifier(account_id, "admin_user", "assistant-admin"),
+ role=Role.ADMIN,
+ )
+
+ with pytest.raises(InvalidArgumentError, match="not a registered user"):
+ await _call_add_message_route(
+ service,
+ monkeypatch,
+ ctx=ctx,
+ payload=_message_request("user", content="hello invalid", role_id="ghost"),
+ api_key_manager=manager,
+ session_id="invalid-user-role-id",
+ )
+
+
async def test_add_multiple_messages(client: httpx.AsyncClient):
create_resp = await client.post("/api/v1/sessions", json={})
session_id = create_resp.json()["result"]["session_id"]
@@ -175,19 +375,19 @@ async def test_add_multiple_messages(client: httpx.AsyncClient):
# the accumulated count (messages are loaded from storage each time)
resp1 = await client.post(
f"/api/v1/sessions/{session_id}/messages",
- json={"role": "user", "content": "Message 0"},
+ json=_message_request("user", content="Message 0"),
)
assert resp1.json()["result"]["message_count"] >= 1
resp2 = await client.post(
f"/api/v1/sessions/{session_id}/messages",
- json={"role": "user", "content": "Message 1"},
+ json=_message_request("user", content="Message 1"),
)
count2 = resp2.json()["result"]["message_count"]
resp3 = await client.post(
f"/api/v1/sessions/{session_id}/messages",
- json={"role": "user", "content": "Message 2"},
+ json=_message_request("user", content="Message 2"),
)
count3 = resp3.json()["result"]["message_count"]
@@ -202,14 +402,14 @@ async def test_add_message_persistence_regression(client: httpx.AsyncClient, ser
resp1 = await client.post(
f"/api/v1/sessions/{session_id}/messages",
- json={"role": "user", "content": "Message A"},
+ json=_message_request("user", content="Message A"),
)
assert resp1.status_code == 200
assert resp1.json()["result"]["message_count"] == 1
resp2 = await client.post(
f"/api/v1/sessions/{session_id}/messages",
- json={"role": "user", "content": "Message B"},
+ json=_message_request("user", content="Message B"),
)
assert resp2.status_code == 200
assert resp2.json()["result"]["message_count"] == 2
@@ -235,7 +435,7 @@ async def test_delete_session(client: httpx.AsyncClient):
# Add a message so the session file exists in storage
await client.post(
f"/api/v1/sessions/{session_id}/messages",
- json={"role": "user", "content": "ensure persisted"},
+ json=_message_request("user", content="ensure persisted"),
)
# Compress to persist
await client.post(f"/api/v1/sessions/{session_id}/commit")
@@ -252,7 +452,7 @@ async def test_compress_session(client: httpx.AsyncClient):
# Add some messages before committing
await client.post(
f"/api/v1/sessions/{session_id}/messages",
- json={"role": "user", "content": "Hello"},
+ json=_message_request("user", content="Hello"),
)
# Default wait=False: returns accepted with task_id
@@ -300,7 +500,7 @@ async def test_get_session_context_endpoint_returns_trimmed_latest_archive_and_m
await client.post(
f"/api/v1/sessions/{session_id}/messages",
- json={"role": "user", "content": "archived message"},
+ json=_message_request("user", content="archived message"),
)
commit_resp = await client.post(f"/api/v1/sessions/{session_id}/commit")
task_id = commit_resp.json()["result"]["task_id"]
@@ -308,9 +508,9 @@ async def test_get_session_context_endpoint_returns_trimmed_latest_archive_and_m
await client.post(
f"/api/v1/sessions/{session_id}/messages",
- json={
- "role": "assistant",
- "parts": [
+ json=_message_request(
+ "assistant",
+ parts=[
{"type": "text", "text": "Running tool"},
{
"type": "tool",
@@ -321,7 +521,7 @@ async def test_get_session_context_endpoint_returns_trimmed_latest_archive_and_m
"tool_status": "running",
},
],
- },
+ ),
)
resp = await client.get(f"/api/v1/sessions/{session_id}/context?token_budget=1")
@@ -350,11 +550,11 @@ async def test_get_session_archive_endpoint_returns_archive_details(client: http
await client.post(
f"/api/v1/sessions/{session_id}/messages",
- json={"role": "user", "content": "archived question"},
+ json=_message_request("user", content="archived question"),
)
await client.post(
f"/api/v1/sessions/{session_id}/messages",
- json={"role": "assistant", "content": "archived answer"},
+ json=_message_request("assistant", content="archived answer"),
)
commit_resp = await client.post(f"/api/v1/sessions/{session_id}/commit")
task_id = commit_resp.json()["result"]["task_id"]
@@ -388,7 +588,7 @@ async def test_commit_endpoint_rejects_after_failed_archive(
await client.post(
f"/api/v1/sessions/{session_id}/messages",
- json={"role": "user", "content": "first round"},
+ json=_message_request("user", content="first round"),
)
commit_resp = await client.post(f"/api/v1/sessions/{session_id}/commit")
task_id = commit_resp.json()["result"]["task_id"]
@@ -397,7 +597,7 @@ async def test_commit_endpoint_rejects_after_failed_archive(
await client.post(
f"/api/v1/sessions/{session_id}/messages",
- json={"role": "user", "content": "second round"},
+ json=_message_request("user", content="second round"),
)
resp = await client.post(f"/api/v1/sessions/{session_id}/commit")
diff --git a/tests/server/test_auth.py b/tests/server/test_auth.py
index aa3a7e152..b8e7c9041 100644
--- a/tests/server/test_auth.py
+++ b/tests/server/test_auth.py
@@ -24,7 +24,7 @@ from openviking.server.identity import ResolvedIdentity, Role
from openviking.server.models import ERROR_CODE_TO_HTTP_STATUS, ErrorInfo, Response
from openviking.service.core import OpenVikingService
from openviking.service.task_tracker import get_task_tracker, reset_task_tracker
-from openviking_cli.exceptions import InvalidArgumentError, OpenVikingError
+from openviking_cli.exceptions import InvalidArgumentError, OpenVikingError, PermissionDeniedError
from openviking_cli.session.user_id import UserIdentifier
@@ -41,6 +41,7 @@ def _make_request(
auth_enabled: bool = True,
auth_mode: str = "api_key",
root_api_key: str | None = None,
+ api_key_manager=None,
) -> Request:
"""Create a minimal Starlette request for auth dependency tests."""
raw_headers = []
@@ -50,7 +51,7 @@ def _make_request(
app.state.config = ServerConfig(auth_mode=auth_mode, root_api_key=root_api_key)
if auth_enabled:
# Non-empty api_key_manager means the server is in authenticated mode.
- app.state.api_key_manager = object()
+ app.state.api_key_manager = api_key_manager if api_key_manager is not None else object()
scope = {
"type": "http",
"path": path,
@@ -372,6 +373,109 @@ async def test_agent_id_header_forwarded(auth_client: httpx.AsyncClient):
assert resp.status_code == 200
+async def test_admin_key_can_switch_effective_user_and_agent_within_account(auth_app):
+ """ADMIN keys may reuse X-OpenViking-User/Agent within their own account."""
+ manager = auth_app.state.api_key_manager
+ account_id = _uid()
+ admin_key = await manager.create_account(account_id, "admin_user")
+ await manager.register_user(account_id, "alice")
+
+ request = _make_request(
+ "/api/v1/resources",
+ headers={
+ "X-API-Key": admin_key,
+ "X-OpenViking-Account": account_id,
+ "X-OpenViking-User": "alice",
+ "X-OpenViking-Agent": "assistant-2",
+ },
+ auth_enabled=True,
+ api_key_manager=manager,
+ )
+
+ identity = await resolve_identity(
+ request,
+ x_api_key=admin_key,
+ x_openviking_account=account_id,
+ x_openviking_user="alice",
+ x_openviking_agent="assistant-2",
+ )
+
+ assert identity.role == Role.ADMIN
+ assert identity.account_id == account_id
+ assert identity.user_id == "alice"
+ assert identity.agent_id == "assistant-2"
+
+
+async def test_admin_key_cannot_switch_account_via_header(auth_app):
+ """ADMIN keys must stay inside their own account."""
+ manager = auth_app.state.api_key_manager
+ account_id = _uid()
+ admin_key = await manager.create_account(account_id, "admin_user")
+
+ request = _make_request(
+ "/api/v1/resources",
+ headers={
+ "X-API-Key": admin_key,
+ "X-OpenViking-Account": "other-account",
+ },
+ auth_enabled=True,
+ api_key_manager=manager,
+ )
+
+ with pytest.raises(PermissionDeniedError, match="X-OpenViking-Account"):
+ await resolve_identity(
+ request,
+ x_api_key=admin_key,
+ x_openviking_account="other-account",
+ )
+
+
+async def test_user_key_can_switch_agent_but_not_user(auth_app):
+ """USER keys may set agent context but may not impersonate another user."""
+ manager = auth_app.state.api_key_manager
+ account_id = _uid()
+ await manager.create_account(account_id, "admin_user")
+ user_key = await manager.register_user(account_id, "alice")
+
+ request = _make_request(
+ "/api/v1/resources",
+ headers={
+ "X-API-Key": user_key,
+ "X-OpenViking-Agent": "assistant-7",
+ },
+ auth_enabled=True,
+ api_key_manager=manager,
+ )
+
+ identity = await resolve_identity(
+ request,
+ x_api_key=user_key,
+ x_openviking_agent="assistant-7",
+ )
+
+ assert identity.role == Role.USER
+ assert identity.account_id == account_id
+ assert identity.user_id == "alice"
+ assert identity.agent_id == "assistant-7"
+
+ forbidden_request = _make_request(
+ "/api/v1/resources",
+ headers={
+ "X-API-Key": user_key,
+ "X-OpenViking-User": "bob",
+ },
+ auth_enabled=True,
+ api_key_manager=manager,
+ )
+
+ with pytest.raises(PermissionDeniedError, match="X-OpenViking-User"):
+ await resolve_identity(
+ forbidden_request,
+ x_api_key=user_key,
+ x_openviking_user="bob",
+ )
+
+
async def test_cross_tenant_session_get_returns_not_found(auth_client: httpx.AsyncClient, auth_app):
"""A user must not access another tenant's session by session_id."""
manager = auth_app.state.api_key_manager
diff --git a/tests/session/memory/test_memory_updater.py b/tests/session/memory/test_memory_updater.py
index 0aaf1244c..0d198d73f 100644
--- a/tests/session/memory/test_memory_updater.py
+++ b/tests/session/memory/test_memory_updater.py
@@ -4,10 +4,13 @@
Tests for MemoryUpdater.
"""
+from types import SimpleNamespace
from unittest.mock import AsyncMock, MagicMock
import pytest
+from openviking.server.identity import AccountNamespacePolicy, RequestContext, Role
+from openviking.session.memory.dataclass import MemoryTypeSchema
from openviking.session.memory.memory_type_registry import MemoryTypeRegistry
from openviking.session.memory.memory_updater import (
MemoryUpdater,
@@ -17,7 +20,13 @@ from openviking.session.memory.merge_op import (
SearchReplaceBlock,
StrPatch,
)
-from openviking.session.memory.utils import deserialize_full, serialize_with_metadata
+from openviking.session.memory.utils import (
+ ResolvedOperation,
+ ResolvedOperations,
+ deserialize_full,
+ serialize_with_metadata,
+)
+from openviking_cli.session.user_id import UserIdentifier
class TestMemoryUpdateResult:
@@ -98,6 +107,88 @@ class TestMemoryUpdater:
assert updater._registry == registry
+ @pytest.mark.asyncio
+ @pytest.mark.parametrize(
+ ("policy", "schema_directory", "resolved_uri", "expected_directory", "memory_type"),
+ [
+ (
+ AccountNamespacePolicy(
+ isolate_user_scope_by_agent=True,
+ isolate_agent_scope_by_user=False,
+ ),
+ "viking://user/{{ user_space }}/memories/preferences",
+ "viking://user/alice/agent/bot/memories/preferences/theme.md",
+ "viking://user/alice/agent/bot/memories/preferences",
+ "preferences",
+ ),
+ (
+ AccountNamespacePolicy(
+ isolate_user_scope_by_agent=False,
+ isolate_agent_scope_by_user=True,
+ ),
+ "viking://agent/{{ agent_space }}/memories/tools",
+ "viking://agent/bot/user/alice/memories/tools/web_search.md",
+ "viking://agent/bot/user/alice/memories/tools",
+ "tools",
+ ),
+ ],
+ )
+ async def test_apply_operations_matches_overview_directories_with_namespace_policy(
+ self,
+ monkeypatch,
+ policy,
+ schema_directory,
+ resolved_uri,
+ expected_directory,
+ memory_type,
+ ):
+ """Overview generation should use policy-expanded user/agent space fragments."""
+ schema = MemoryTypeSchema(
+ memory_type=memory_type,
+ description=f"{memory_type} memory",
+ directory=schema_directory,
+ filename_template="{{ name }}.md",
+ fields=[],
+ overview_template="overview",
+ )
+ registry = MagicMock()
+ registry.list_all.return_value = [schema]
+
+ updater = MemoryUpdater(registry=registry)
+ updater._get_viking_fs = MagicMock(return_value=MagicMock())
+ updater._apply_edit = AsyncMock(return_value=False)
+ updater._vectorize_memories = AsyncMock()
+ updater.generate_overview = AsyncMock()
+
+ resolved = ResolvedOperations()
+ resolved.operations.append(
+ ResolvedOperation(
+ model={"name": "demo"},
+ uri=resolved_uri,
+ memory_type=memory_type,
+ )
+ )
+ monkeypatch.setattr(
+ "openviking.session.memory.memory_updater.resolve_all_operations",
+ lambda *args, **kwargs: resolved,
+ )
+
+ ctx = RequestContext(
+ user=UserIdentifier("acme", "alice", "bot"),
+ role=Role.USER,
+ namespace_policy=policy,
+ )
+
+ result = await updater.apply_operations(operations=SimpleNamespace(), ctx=ctx)
+
+ assert result.written_uris == [resolved_uri]
+ updater.generate_overview.assert_awaited_once_with(
+ memory_type,
+ expected_directory,
+ ctx,
+ None,
+ )
+
# The TestApplyWriteWithContentInFields tests are outdated because WriteOp no longer exists
# The _apply_write method now accepts any flat model (dict or Pydantic model) that
diff --git a/tests/storage/test_embedding_msg_converter_tenant.py b/tests/storage/test_embedding_msg_converter_tenant.py
index 0a3e08c41..73bc5c95b 100644
--- a/tests/storage/test_embedding_msg_converter_tenant.py
+++ b/tests/storage/test_embedding_msg_converter_tenant.py
@@ -11,32 +11,47 @@ from openviking_cli.session.user_id import UserIdentifier
@pytest.mark.parametrize(
- ("uri", "expected_space"),
+ ("uri", "expected_owner_user_id", "expected_owner_agent_id"),
[
(
"viking://user/memories/preferences/me.md",
- lambda user: user.user_space_name(),
+ lambda user: user.user_id,
+ None,
),
(
"viking://agent/memories/cases/me.md",
- lambda user: user.agent_space_name(),
+ None,
+ lambda user: user.agent_id,
),
(
"viking://resources/doc.md",
- lambda _user: "",
+ None,
+ None,
),
],
)
-def test_embedding_msg_converter_backfills_account_and_owner_space(uri, expected_space):
+def test_embedding_msg_converter_backfills_account_and_owner_fields(
+ uri, expected_owner_user_id, expected_owner_agent_id
+):
user = UserIdentifier("acme", "alice", "helper")
context = Context(uri=uri, abstract="hello", user=user)
# Simulate legacy producer that forgot tenant fields.
context.account_id = ""
- context.owner_space = ""
+ context.owner_user_id = None
+ context.owner_agent_id = None
msg = EmbeddingMsgConverter.from_context(context)
assert msg is not None
assert msg.context_data["account_id"] == "acme"
- assert msg.context_data["owner_space"] == expected_space(user)
+ expected_user = (
+ expected_owner_user_id(user) if callable(expected_owner_user_id) else expected_owner_user_id
+ )
+ expected_agent = (
+ expected_owner_agent_id(user)
+ if callable(expected_owner_agent_id)
+ else expected_owner_agent_id
+ )
+ assert msg.context_data["owner_user_id"] == expected_user
+ assert msg.context_data["owner_agent_id"] == expected_agent
diff --git a/tests/test_config_loader.py b/tests/test_config_loader.py
index bcb470d0c..39dc0b7ca 100644
--- a/tests/test_config_loader.py
+++ b/tests/test_config_loader.py
@@ -169,6 +169,23 @@ def test_openviking_config_rejects_unknown_top_level_section_with_suggestion(mon
OpenVikingConfigSingleton.reset_instance()
+def test_openviking_config_warns_when_agent_scope_mode_is_configured(monkeypatch, caplog):
+ monkeypatch.setenv("OPENVIKING_CONFIG_FILE", "/tmp/codex-no-config.json")
+
+ from openviking_cli.utils.config.open_viking_config import (
+ OpenVikingConfig,
+ OpenVikingConfigSingleton,
+ )
+
+ with caplog.at_level("WARNING"):
+ config = OpenVikingConfig.from_dict({"memory": {"agent_scope_mode": "agent"}})
+
+ assert config.memory.agent_scope_mode == "agent"
+ assert "memory.agent_scope_mode is deprecated and ignored" in caplog.text
+
+ OpenVikingConfigSingleton.reset_instance()
+
+
def test_openviking_config_singleton_preserves_value_error_for_bad_config(tmp_path, monkeypatch):
monkeypatch.setenv(OPENVIKING_CONFIG_ENV, "/tmp/codex-no-config.json")
diff --git a/tests/unit/test_context.py b/tests/unit/test_context.py
index 9a34d14da..039117351 100644
--- a/tests/unit/test_context.py
+++ b/tests/unit/test_context.py
@@ -482,33 +482,40 @@ class TestContextWithUser:
assert ctx.account_id == user.account_id
- def test_owner_space_agent(self):
- """Test owner_space for agent URI."""
+ def test_owner_fields_agent(self):
+ """Test owner fields for canonical agent URI."""
user = UserIdentifier(account_id="account-123", user_id="user-123", agent_id="agent-456")
ctx = Context(uri="viking://agent/test/skills/my-skill/", user=user)
- assert ctx.owner_space == user.agent_space_name()
+ assert ctx.owner_user_id is None
+ assert ctx.owner_agent_id == "test"
+ assert ctx.owner_space == user.agent_id
- def test_owner_space_user(self):
- """Test owner_space for user URI."""
+ def test_owner_fields_user(self):
+ """Test owner fields for canonical user URI."""
user = UserIdentifier(account_id="account-123", user_id="user-123", agent_id="agent-456")
ctx = Context(uri="viking://user/test/memories/test.md", user=user)
- assert ctx.owner_space == user.user_space_name()
+ assert ctx.owner_user_id == "test"
+ assert ctx.owner_agent_id is None
+ assert ctx.owner_space == user.user_id
- def test_owner_space_session(self):
- """Test owner_space for session URI."""
+ def test_owner_fields_session(self):
+ """Test owner fields for session URI."""
user = UserIdentifier(account_id="account-123", user_id="user-123", agent_id="agent-456")
ctx = Context(uri="viking://session/test/msg/1.md", user=user)
- assert ctx.owner_space == user.user_space_name()
+ assert ctx.owner_user_id is None
+ assert ctx.owner_agent_id is None
+ assert ctx.owner_space == user.user_id
- def test_owner_space_resource_default(self):
- """Test owner_space default for resource URI."""
+ def test_owner_fields_resource_default(self):
+ """Test owner fields default for resource URI."""
user = UserIdentifier(account_id="account-123", user_id="user-123", agent_id="agent-456")
ctx = Context(uri="viking://resources/docs/test.md", user=user)
- # Resource URIs don't match agent/user/session patterns
+ assert ctx.owner_user_id is None
+ assert ctx.owner_agent_id is None
assert ctx.owner_space == ""