Self-evolving Context Database for AI Agents. Unify Agent Memory, Knowledge RAG and Skills.
Python agent-contextagent-memoryagent-pluginsagentic-ragcontext-databasedsh-pluginknowledge-basememorymemory-managementself-evolvingvector-database
feat(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.rsindex 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 filefn 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.mdnew file mode 100644index 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.mdindex 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 Operationsdiff --git a/docs/en/concepts/11-multi-tenant.md b/docs/en/concepts/11-multi-tenant.mdindex 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 Layerdiff --git a/docs/en/guides/01-configuration.md b/docs/en/guides/01-configuration.mdindex 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.confdiff --git a/docs/en/guides/09-ovpack.md b/docs/en/guides/09-ovpack.mdindex 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 = falseopenviking export viking://agent/default/memories/ ./exports/agent-memories.ovpackopenviking 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.mdindex 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.mdindex 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.mdindex 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.confdiff --git a/docs/zh/guides/09-ovpack.md b/docs/zh/guides/09-ovpack.mdindex 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 = falseopenviking export viking://agent/default/memories/ ./exports/agent-memories.ovpackopenviking 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.pynew file mode 100644index 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.pyindex 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.pyindex 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.pyindex 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.jsindex 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__.pyindex 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__ = [# Contextdiff --git a/openviking/core/context.py b/openviking/core/context.pyindex 55bce1c47..612437bde 100644--- a/openviking/core/context.py+++ b/openviking/core/context.py@@ -7,6 +7,7 @@ from enum import Enumfrom typing import Any, Dict, List, Optionalfrom uuid import uuid4+from openviking.core.namespace import owner_fields_for_urifrom openviking.utils.time_utils import format_iso8601, parse_iso_datetimefrom openviking_cli.session.user_id import UserIdentifierfrom 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_idself.user = userself.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]] = Noneself.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_idif self.uri.startswith("viking://user/") or self.uri.startswith("viking://session/"):- return user.user_space_name()+ return user.user_idreturn ""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.pyindex e0dedb0f0..3621c553c 100644--- a/openviking/core/directories.py+++ b/openviking/core/directories.py@@ -11,11 +11,18 @@ from dataclasses import dataclass, fieldfrom typing import TYPE_CHECKING, Dict, List, Optionalfrom 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 RequestContextfrom openviking.storage.queuefs.embedding_msg_converter import EmbeddingMsgConverterif 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_uricreated = 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_uricreated = 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:@staticmethoddef _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 Trueexcept 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.pynew file mode 100644index 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_policydiff --git a/openviking/message/message.py b/openviking/message/message.pyindex b14867f52..c0cba66f6 100644--- a/openviking/message/message.py+++ b/openviking/message/message.py@@ -20,6 +20,7 @@ class Message:id: strrole: Literal["user", "assistant"]parts: List[Part]+ role_id: Optional[str] = Nonecreated_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.pyindex 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] = Nonetool_output: str = ""tool_status: str = "pending" # pending | running | completed | errordiff --git a/openviking/retrieve/hierarchical_retriever.py b/openviking/retrieve/hierarchical_retriever.pyindex 5c7419200..338caf8ec 100644--- a/openviking/retrieve/hierarchical_retriever.py+++ b/openviking/retrieve/hierarchical_retriever.py@@ -14,6 +14,7 @@ import timefrom datetime import datetimefrom typing import Any, Dict, List, Optional, Tuple+from openviking.core.namespace import canonical_agent_root, canonical_user_rootfrom openviking.models.embedder.base import EmbedResult, embed_compatfrom openviking.models.rerank import RerankClientfrom 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.pyindex e252454af..493d6c0ac 100644--- a/openviking/server/api_keys.py+++ b/openviking/server/api_keys.py@@ -12,7 +12,7 @@ from typing import Dict, Optionalfrom argon2 import PasswordHasherfrom argon2.exceptions import VerifyMismatchError-from openviking.server.identity import ResolvedIdentity, Role+from openviking.server.identity import AccountNamespacePolicy, ResolvedIdentity, Rolefrom openviking.storage.viking_fs import VikingFSfrom 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: strusers: 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 Noneif accounts_data is None:# First run: create default accountnow = 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 keyasync 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.pyindex 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_managerlogger.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 = Nonediff --git a/openviking/server/auth.py b/openviking/server/auth.pyindex 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_idset_metric_account_context(account_id=ctx.account_id)diff --git a/openviking/server/identity.py b/openviking/server/identity.pyindex 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,+ }++@dataclassclass ResolvedIdentity:"""Output of auth middleware: raw identity resolved from API Key."""@@ -23,6 +46,7 @@ class ResolvedIdentity:account_id: Optional[str] = Noneuser_id: Optional[str] = Noneagent_id: Optional[str] = None+ namespace_policy: AccountNamespacePolicy = field(default_factory=AccountNamespacePolicy)@dataclass@@ -31,6 +55,7 @@ class RequestContext:user: UserIdentifierrole: Role+ namespace_policy: AccountNamespacePolicy = field(default_factory=AccountNamespacePolicy)@propertydef account_id(self) -> str:diff --git a/openviking/server/routers/admin.py b/openviking/server/routers/admin.pyindex 9e0e5682d..8f7fe3456 100644--- a/openviking/server/routers/admin.py+++ b/openviking/server/routers/admin.py@@ -7,7 +7,7 @@ from pydantic import BaseModelfrom openviking.server.auth import get_request_contextfrom openviking.server.dependencies import get_service-from openviking.server.identity import RequestContext, Role+from openviking.server.identity import AccountNamespacePolicy, RequestContext, Rolefrom openviking.server.models import Responsefrom openviking.storage.viking_fs import get_viking_fsfrom openviking_cli.exceptions import PermissionDeniedError@@ -33,6 +33,8 @@ _DEV_MODE_ADMIN_API_MESSAGE = (class CreateAccountRequest(BaseModel):account_id: stradmin_user_id: str+ isolate_user_scope_by_agent: bool = False+ isolate_agent_scope_by_user: bool = Falseclass 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.pyindex 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 refrom typing import Any, Dict, List, Literal, Optional-from fastapi import APIRouter, Depends, Path, Query+from fastapi import APIRouter, Depends, Path, Query, Requestfrom pydantic import BaseModel, model_validatorfrom openviking.message.part import TextPart, part_from_dictfrom openviking.server.auth import get_request_contextfrom openviking.server.dependencies import get_service-from openviking.server.identity import RequestContext+from openviking.server.identity import RequestContext, Rolefrom openviking.server.models import ErrorInfo, Response+from openviking_cli.exceptions import InvalidArgumentErrorrouter = 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] = Nonecontent: Optional[str] = Noneparts: Optional[List[Dict[str, Any]]] = Nonecreated_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.pyindex 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_initializerdefault_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.pyindex 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, Rolefrom openviking.service.task_tracker import get_task_trackerfrom openviking.session import Sessionfrom 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 Nonediff --git a/openviking/session/compressor_v2.py b/openviking/session/compressor_v2.pyindex 2d5ce523f..0afda749d 100644--- a/openviking/session/compressor_v2.py+++ b/openviking/session/compressor_v2.py@@ -11,16 +11,16 @@ import asynciofrom typing import List, Optionalfrom openviking.core.context import Context+from openviking.core.namespace import agent_space_fragment, user_space_fragmentfrom openviking.message import Messagefrom openviking.server.identity import RequestContextfrom openviking.session.memory import ExtractLoop, MemoryUpdaterfrom openviking.session.memory.utils.json_parser import JsonUtilsfrom openviking.storage import VikingDBManagerfrom openviking.storage.viking_fs import get_viking_fs-from openviking.telemetry import get_current_telemetry+from openviking.telemetry import get_current_telemetry, tracerfrom openviking_cli.session.user_id import UserIdentifierfrom openviking_cli.utils import get_logger-from openviking.telemetry import tracerfrom openviking_cli.utils.config import get_openviking_configlogger = 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 渲染 directoryimport 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.pyindex 191a19340..ffd521e6c 100644--- a/openviking/session/memory/extract_loop.py+++ b/openviking/session/memory/extract_loop.py@@ -10,6 +10,7 @@ import asyncioimport jsonfrom typing import Any, Dict, List, Optional, Set, Tuple+from openviking.core.namespace import agent_space_fragment, user_space_fragmentfrom openviking.models.vlm.base import VLMBasefrom openviking.server.identity import RequestContextfrom openviking.session.memory.schema_model_generator import (@@ -330,8 +331,8 @@ The final output of the model must strictly follow the JSON Schema format shownoperations,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 shownuri = 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.pyindex 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, Optionalimport yaml+from openviking.core.namespace import agent_space_fragment, user_space_fragmentfrom openviking.session.memory.dataclass import MemoryField, MemoryTypeSchemafrom openviking.session.memory.merge_op import MergeOpfrom 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.pyindex 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, Tupleimport jinja2++from openviking.core.namespace import agent_space_fragment, user_space_fragmentfrom openviking.message import Messagefrom openviking.server.identity import RequestContextfrom openviking.session.memory.dataclass import MemoryFieldfrom openviking.session.memory.memory_type_registry import MemoryTypeRegistry-from openviking.session.memory.merge_op import MergeOpFactory, PatchOp+from openviking.session.memory.merge_op import MergeOpFactoryfrom 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 directoryif dir_path.startswith(base_dir.rstrip("/")):@@ -350,7 +352,9 @@ class MemoryUpdater:# Generate overview for each unique directoryfor 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 typeregistry = self._registrytracer.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 pathfilename = 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}")continuediff --git a/openviking/session/memory/session_extract_context_provider.py b/openviking/session/memory/session_extract_context_provider.pyindex 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 jsonimport 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_fragmentfrom openviking.server.identity import RequestContextfrom openviking.session.memory.core import ExtractContextProviderfrom 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 tracerfrom openviking_cli.utils import get_loggerfrom openviking_cli.utils.config import get_openviking_configlogger = 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 prSee 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/deletcontinue# 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 jinja2env = jinja2.Environment(autoescape=False)diff --git a/openviking/session/memory_deduplicator.py b/openviking/session/memory_deduplicator.pyindex c57ae8216..22369696c 100644--- a/openviking/session/memory_deduplicator.py+++ b/openviking/session/memory_deduplicator.py@@ -15,6 +15,7 @@ from enum import Enumfrom typing import Dict, List, Optionalfrom openviking.core.context import Context+from openviking.core.namespace import canonical_agent_root, canonical_user_rootfrom openviking.models.embedder.base import EmbedResult, embed_compatfrom openviking.prompts import render_promptfrom 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.pyindex fefef0ba7..1ea96434a 100644--- a/openviking/session/memory_extractor.py+++ b/openviking/session/memory_extractor.py@@ -15,6 +15,7 @@ from typing import List, Optionalfrom uuid import uuid4from openviking.core.context import Context, ContextType, Vectorize+from openviking.core.namespace import canonical_agent_root, canonical_user_rootfrom openviking.prompts import render_promptfrom openviking.server.identity import RequestContextfrom 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@staticmethoddef _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.pyindex b6ec14965..a9da3d441 100644--- a/openviking/session/session.py+++ b/openviking/session/session.py@@ -13,6 +13,7 @@ from datetime import datetime, timezonefrom typing import TYPE_CHECKING, Any, Dict, List, Optionalfrom uuid import uuid4+from openviking.core.namespace import canonical_session_urifrom openviking.message import Message, Partfrom openviking.server.identity import RequestContext, Rolefrom 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 = 0commit_count: int = 0memories_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 = Falselogger.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 = Trueasync 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 statisticsif 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.pyindex 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, Rolefrom openviking.storage.errors import (CollectionNotFoundError,EmbeddingConfigurationError,- EmbeddingRebuildRequiredError,)from openviking.storage.queuefs.embedding_msg import EmbeddingMsgfrom 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 = 0except 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_afterif wait > 0:await asyncio.sleep(wait)@@ -489,7 +490,7 @@ class TextEmbeddingHandler(DequeueHandlerBase):# Transient or unknown — re-enqueue for retrylogger.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.pyindex 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_urifrom openviking.storage.queuefs.embedding_msg import EmbeddingMsgfrom openviking.telemetry import get_current_telemetryfrom 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.pyindex dc1437800..3f4217a3c 100644--- a/openviking/storage/queuefs/semantic_processor.py+++ b/openviking/storage/queuefs/semantic_processor.py@@ -8,6 +8,7 @@ from contextlib import nullcontextfrom dataclasses import dataclass, fieldfrom typing import Any, Dict, List, Optional, Set, Tuple+from openviking.core.namespace import agent_space_fragment, user_space_fragmentfrom 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.pyindex c6f6bc82f..8429f43c5 100644--- a/openviking/storage/viking_fs.py+++ b/openviking/storage/viking_fs.py@@ -23,13 +23,25 @@ from datetime import datetimefrom pathlib import PurePathfrom 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, AGFSHTTPErrorfrom openviking.resource.watch_storage import is_watch_task_control_urifrom openviking.server.error_mapping import is_not_found_error, map_exceptionfrom openviking.server.identity import RequestContext, Rolefrom openviking.telemetry import get_current_telemetryfrom 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 UserIdentifierfrom openviking_cli.utils.logger import get_loggerfrom 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 excself._ensure_access(target_uri, ctx)storage = self._get_vector_store()@@ -1095,6 +1119,16 @@ class VikingFS:# Normalize target_uri to listtarget_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 checkprimary_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:+ passexcept AGFSHTTPError as e:if e.status_code != 404:raise@@ -1892,19 +1920,22 @@ class VikingFS:if len(all_entries) >= node_limit:breakname = entry.get("name", "")- # After modification: compatible with 7+ digits of microseconds by truncatingraw_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):continuediff --git a/openviking/storage/viking_vector_index_backend.py b/openviking/storage/viking_vector_index_backend.pyindex 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 annotationsimport uuidfrom typing import Any, Dict, List, Optional+from openviking.core.namespace import canonicalize_uri, visible_rootsfrom openviking.server.identity import RequestContext, Rolefrom openviking.storage.expr import And, Eq, FilterExpr, In, Or, PathScope, RawDSLfrom 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_directoriesif 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_directoriesif 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])@staticmethoddef _merge_filters(*filters: Optional[FilterExpr]) -> Optional[FilterExpr]:diff --git a/openviking/sync_client.py b/openviking/sync_client.pyindex 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.pyindex ef9151e0b..e0e23ca1b 100644--- a/openviking/utils/embedding_utils.py+++ b/openviking/utils/embedding_utils.py@@ -12,6 +12,7 @@ from typing import Dict, Optionalfrom openviking.core.context import Context, ContextLevel, ResourceContentType, Vectorizefrom openviking.core.directories import get_context_type_for_uri+from openviking.core.namespace import agent_space_fragment, user_space_fragmentfrom openviking.server.identity import RequestContextfrom openviking.storage.queuefs import get_queue_managerfrom openviking.storage.queuefs.embedding_msg_converter import EmbeddingMsgConverter@@ -42,9 +43,9 @@ async def _decrement_embedding_tracker(semantic_msg_id: Optional[str], count: indef _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.pyindex 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, Optionalfrom openviking.core.context import Context, ContextType, Vectorizefrom openviking.core.mcp_converter import is_mcp_format, mcp_to_skill+from openviking.core.namespace import agent_space_fragment, canonical_agent_rootfrom openviking.core.skill_loader import SkillLoaderfrom openviking.server.identity import RequestContextfrom 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.pyindex 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.pyindex 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_idresponse = 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.pyindex 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.pyindex 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_iddef _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.pyindex 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.pyindex 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.0import json+import loggingimport osfrom pathlib import Pathfrom threading import Lock@@ -228,6 +229,15 @@ class OpenVikingConfig(BaseModel):# Apply memory configurationif 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.dimensionemb_dim = instance.embedding.dimensionif 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.pyindex 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_URLself.server_url = server_url or Config.SERVER_URLself.api_key = api_key or Config.OPENVIKING_API_KEYself.account = account or Config.OPENVIKING_ACCOUNTself.user = user or Config.OPENVIKING_USER+ self.agent = agent or Config.OPENVIKING_AGENTself.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.pyindex 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 = 30CONSOLE_STARTUP_TIMEOUT = 30diff --git a/tests/cli/test_user_identifier.py b/tests/cli/test_user_identifier.pyindex 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 OpenVikingConfigSingletonclass TestAgentSpaceNameCollision:@@ -35,23 +32,10 @@ class TestAgentSpaceNameCollision:assert len(name) == 12assert 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.pyindex 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 20print(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 20print(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.pyindex 1055dd938..85eed2136 100644--- a/tests/server/test_api_key_manager.py+++ b/tests/server/test_api_key_manager.py@@ -9,7 +9,7 @@ import pytestimport pytest_asynciofrom openviking.server.api_keys import APIKeyManager-from openviking.server.identity import Role+from openviking.server.identity import AccountNamespacePolicy, Rolefrom openviking.service.core import OpenVikingServicefrom openviking_cli.exceptions import AlreadyExistsError, NotFoundError, UnauthenticatedErrorfrom 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.pyindex f3f376468..80453252c 100644--- a/tests/server/test_api_search.py+++ b/tests/server/test_api_search.py@@ -9,7 +9,10 @@ import httpximport pytestfrom openviking.models.embedder.base import EmbedResult+from openviking.server.auth import get_request_context+from openviking.server.identity import RequestContext, Rolefrom 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_resourceresp = await client.post(diff --git a/tests/server/test_api_sessions.py b/tests/server/test_api_sessions.pyindex 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 patchimport httpximport pytest+from fastapi import FastAPI+from starlette.requests import Requestfrom openviking.message import Message+from openviking.server.api_keys import APIKeyManager+from openviking.server.config import ServerConfigfrom openviking.server.identity import RequestContext, Role+from openviking.server.routers import sessions as sessions_router+from openviking_cli.exceptions import InvalidArgumentErrorfrom openviking_cli.session.user_id import UserIdentifierfrom openviking_cli.utils.config import OPENVIKING_CONFIG_ENVfrom openviking_cli.utils.config.open_viking_config import OpenVikingConfigSingletonfrom 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: floatraise 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 == 200body = 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"] >= 1resp2 = 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, serresp1 = 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 == 200assert resp1.json()["result"]["message_count"] == 1resp2 = 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 == 200assert 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 storageawait client.post(f"/api/v1/sessions/{session_id}/messages",- json={"role": "user", "content": "ensure persisted"},+ json=_message_request("user", content="ensure persisted"),)# Compress to persistawait 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 committingawait 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_mawait 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_mawait 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: httpawait 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.pyindex 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, Rolefrom openviking.server.models import ERROR_CODE_TO_HTTP_STATUS, ErrorInfo, Responsefrom openviking.service.core import OpenVikingServicefrom 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, PermissionDeniedErrorfrom 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_managerdiff --git a/tests/session/memory/test_memory_updater.py b/tests/session/memory/test_memory_updater.pyindex 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 SimpleNamespacefrom unittest.mock import AsyncMock, MagicMockimport pytest+from openviking.server.identity import AccountNamespacePolicy, RequestContext, Role+from openviking.session.memory.dataclass import MemoryTypeSchemafrom openviking.session.memory.memory_type_registry import MemoryTypeRegistryfrom 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 UserIdentifierclass 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) thatdiff --git a/tests/storage/test_embedding_msg_converter_tenant.py b/tests/storage/test_embedding_msg_converter_tenant.pyindex 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 = Nonemsg = EmbeddingMsgConverter.from_context(context)assert msg is not Noneassert 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_agentdiff --git a/tests/test_config_loader.py b/tests/test_config_loader.pyindex 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(monOpenVikingConfigSingleton.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.pyindex 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 Noneassert ctx.owner_space == ""