diff --git a/agent b/agent index eeff4ef8..d30f69d9 160000 --- a/agent +++ b/agent @@ -1 +1 @@ -Subproject commit eeff4ef8f2f411cc3a059197dff021722222baf8 +Subproject commit d30f69d92837caa33b2fddb9c199a4e3d84750a4 diff --git a/desktop/ARCHITECTURE.md b/desktop/ARCHITECTURE.md index 322ada9c..02a19a3b 100644 --- a/desktop/ARCHITECTURE.md +++ b/desktop/ARCHITECTURE.md @@ -144,14 +144,13 @@ Op/Ev/错误码、proto:1、20s ping。 - 9 个 browser_* 工具经壳内 MCP streamable-http server 暴露给引擎 (Bearer 鉴权;手写最小面:POST json 应答/通知 202/GET 405)。 - **会话隔离并发**:每条 MCP transport 经 `initialize` 取得独立 - `Mcp-Session-Id` 并拥有独立 `BrowserSession`。同一 transport 内串行保护 - current tab/ref 表,不同 transport 可并行进入扩展桥;实现只依赖标准 MCP - 会话头,不要求 Agent 私有 `_meta`。当前 Agent 的子任务共享父 transport, - 因而共享父浏览器现场并按序执行;不同顶层任务各自建 transport,可并行。 + `Mcp-Session-Id`;Agent 的 `tools/call._meta` 再携带实际 `session_id` 与 + `work_dir`。两级 key 为父任务和共享 transport 的子 Agent 分配独立 + `BrowserSession`。同一现场串行保护 current tab/ref,不同现场可并行。 `tabId → owner` 路由保证事件只投给所属任务;普通选择不能抢占其他任务的 - tab,只有用户显式 handoff 才转交。MCP 标准调用不含 cwd:唯一活跃 - workspace 可确定时落截图;无法确定时只跳过本地副本、不拒绝操作,图片 - 仍作为 MCP image 返回模型。 + tab,只有用户显式 handoff 才转交。截图按 `work_dir` 精确落盘;旧 Agent + 缺少元数据时回退唯一活跃 workspace,无法确定只跳过本地副本、不拒绝 + 操作,图片仍作为 MCP image 返回模型。 - 错误码→中文可行动文案是产品契约(模型行为依赖),改动需过 e2e 断言。 ## 引擎监督 diff --git a/desktop/README.md b/desktop/README.md index 1d5c7bee..0f7a45b9 100644 --- a/desktop/README.md +++ b/desktop/README.md @@ -46,6 +46,6 @@ make windows # NSIS 安装包(在 Windows 上执行;或走 CI) `../browser-extension/` 随包分发(设置页引导加载);扩展经 `ws://127.0.0.1:{7440-7449}/ext` 连壳内桥,配对码在设置页展示。 -browser_* 工具经壳内 MCP server 暴露给引擎;每条 MCP transport 有独立 -浏览器现场和标签页归属,不同 transport 可并行,同一 transport 内按调用 -顺序执行。该隔离只依赖标准 `Mcp-Session-Id`,不修改 Agent。 +browser_* 工具经壳内 MCP server 暴露给引擎;`Mcp-Session-Id` 与 Agent +调用 `_meta.session_id` 共同标识浏览器现场,父任务/子 Agent 可并行且标签页 +归属隔离,同一现场内按调用顺序执行。 diff --git a/desktop/src/browser/mcp.rs b/desktop/src/browser/mcp.rs index 17f28c14..d8922304 100644 --- a/desktop/src/browser/mcp.rs +++ b/desktop/src/browser/mcp.rs @@ -8,9 +8,9 @@ // 鉴权:随机 Bearer token,经 mcp.json 内置条目的 headers 下发给引擎—— // MCP 面能驱动用户浏览器,不能对本机任意进程裸奔。 // -// 并发模型:每条 MCP protocol session 拥有独立 BrowserSession;同一 -// transport 内工具串行(共享 current tab/ref 表),不同 transport 可并行。 -// Desktop 不依赖 Agent 私有字段,只使用标准 Mcp-Session-Id。 +// 并发模型:Mcp-Session-Id 隔离 transport,tools/call._meta.session_id 再 +// 隔离共用 transport 的父/子 Agent;每个 context 独享 BrowserSession。 +// 同一 context 内串行保护 current tab/ref,不同 context 可并行。 use std::collections::HashMap; use std::io::{Read as _, Write as _}; @@ -24,9 +24,15 @@ use serde_json::{json, Value}; use super::ops::tool_metas; use super::session::{BrowserSession, BrowserSessions}; +#[derive(Clone, Default)] +pub struct CallScope { + pub session_id: Option, + pub work_dir: Option, +} + /// 解析/校验调用工作区。None 只跳过截图落盘,不影响浏览器操作;owner -/// 隔离由标准 MCP protocol session 完成,不再拿工作区充当并发锁。 -pub type WorkdirFn = Arc Result, String> + Send + Sync>; +/// 隔离由 MCP protocol session + Agent session id 完成,不拿工作区充当锁。 +pub type WorkdirFn = Arc Result, String> + Send + Sync>; #[derive(Clone)] pub struct McpSessions(Arc); @@ -38,7 +44,7 @@ struct McpSessionsInner { struct McpClientSession { closed: AtomicBool, - context: Arc, + contexts: StdMutex>>, } struct McpCallContext { @@ -47,9 +53,11 @@ struct McpCallContext { } impl McpClientSession { - fn close_context(&self) -> Arc { + fn drain_contexts(&self) -> Vec> { + // 先封门再等 contexts 锁:已进临界区的创建会被随后 drain,尚未进入 + // 的创建会看到 closed。DELETE/reset 后不会晚生幽灵 context。 self.closed.store(true, Ordering::Release); - self.context.clone() + self.contexts.lock().unwrap().drain().map(|(_, context)| context).collect() } } @@ -63,15 +71,11 @@ impl McpSessions { fn create(&self) -> Result { let id = new_token()?; - let context = Arc::new(McpCallContext { - browser: self.0.browser.get_or_create(&id), - call_mu: tokio::sync::Mutex::new(()), - }); self.0.clients.lock().unwrap().insert( id.clone(), Arc::new(McpClientSession { closed: AtomicBool::new(false), - context, + contexts: StdMutex::new(HashMap::new()), }), ); Ok(id) @@ -81,22 +85,36 @@ impl McpSessions { self.0.clients.lock().unwrap().contains_key(id) } - fn context(&self, protocol_id: &str) -> Option> { + fn context(&self, protocol_id: &str, agent_id: Option<&str>) -> Option> { let client = self.0.clients.lock().unwrap().get(protocol_id).cloned()?; + let key = agent_id.filter(|id| !id.is_empty()).unwrap_or("root"); + let mut contexts = client.contexts.lock().unwrap(); if client.closed.load(Ordering::Acquire) { return None; } - Some(client.context.clone()) + Some( + contexts + .entry(key.to_string()) + .or_insert_with(|| { + let owner = format!("{protocol_id}:{key}"); + Arc::new(McpCallContext { + browser: self.0.browser.get_or_create(&owner), + call_mu: tokio::sync::Mutex::new(()), + }) + }) + .clone(), + ) } async fn remove(&self, id: &str) -> bool { let client = self.0.clients.lock().unwrap().remove(id); let Some(client) = client else { return false }; - let context = client.close_context(); - // DELETE 可与最后一个 tools/call 同时到达。先从协议注册表摘除, - // 再等调用锁,确保不会在旧调用仍操作 tab 时 detach。 - let _guard = context.call_mu.lock().await; - context.browser.close().await; + for context in client.drain_contexts() { + // DELETE 可与最后一个 tools/call 同时到达。先从协议注册表摘除, + // 再等 context 调用锁,确保不会在旧调用仍操作 tab 时 detach。 + let _guard = context.call_mu.lock().await; + context.browser.close().await; + } true } @@ -109,9 +127,10 @@ impl McpSessions { std::mem::take(&mut *clients).into_values().collect::>() }; for client in clients { - let context = client.close_context(); - let _guard = context.call_mu.lock().await; - context.browser.close().await; + for context in client.drain_contexts() { + let _guard = context.call_mu.lock().await; + context.browser.close().await; + } } } } @@ -281,13 +300,14 @@ async fn dispatch( "tools/call" => { let name = params.get("name").and_then(|v| v.as_str()).unwrap_or("").to_string(); let args = params.get("arguments").cloned().unwrap_or(json!({})); + let scope = call_scope(¶ms); let context = sessions - .context(protocol_id) + .context(protocol_id, scope.session_id.as_deref()) .ok_or_else(|| (-32001, "MCP 会话已关闭".to_string()))?; - // 同一 protocol session 的 current-tab/ref 状态串行;不同 - // transport 没有共享可变现场,可并行进入扩展桥。 + // 同一 Agent context 的 current-tab/ref 状态串行;不同 context + // 没有共享可变现场,可并行进入扩展桥。 let _g = context.call_mu.lock().await; - let out = match workdir() { + let out = match workdir(&scope) { Err(e) => Err(e), Ok(owner_workdir) => tokio::time::timeout( std::time::Duration::from_secs(180), @@ -311,6 +331,19 @@ async fn dispatch( } } +fn call_scope(params: &Value) -> CallScope { + let meta = params.get("_meta"); + let value = |key: &str| meta.and_then(|value| value.get(key)).and_then(Value::as_str); + CallScope { + session_id: value("session_id") + .map(str::trim) + .filter(|value| !value.is_empty()) + .map(str::to_string), + // work_dir 是文件系统值,不裁剪合法的首尾空格。 + work_dir: value("work_dir").filter(|value| !value.is_empty()).map(str::to_string), + } +} + /// 工具分派:名称/入参形态对齐 ops.rs 的 tool_metas(即 Go tools.go)。 async fn call_tool( sess: &BrowserSession, diff --git a/desktop/src/browser/mod.rs b/desktop/src/browser/mod.rs index 52d90ca7..2374d833 100644 --- a/desktop/src/browser/mod.rs +++ b/desktop/src/browser/mod.rs @@ -12,9 +12,9 @@ // mcp.rs MCP streamable-http server:配对后把工具暴露给 ohmyagent // (Bearer 鉴权,URL+token 经 mcp.json 内置条目物化下发) // -// MCP initialize 为每条客户端 transport 分配协议会话;每个 protocol -// session 各自拥有 BrowserSession,允许不同任务并行,同时隔离 current -// tab/ref 表。只依赖标准 Mcp-Session-Id,不要求 Agent 私有扩展。 +// MCP initialize 为每条客户端 transport 分配协议会话;Agent 在 tools/call +// `_meta` 携带实际 session_id/work_dir。两级 key 各自拥有 BrowserSession, +// 允许父任务与子 Agent 并行,同时隔离 current tab/ref 与截图落盘路径。 pub mod bridge; pub mod cdp; @@ -70,17 +70,26 @@ pub fn init(app: &AppHandle) { }; let b = bridge::ExtBridge::new(7440, &data_dir); let mcp_sessions = mcp::McpSessions::new(b.clone()); - // MCP 标准请求不携带调用方 cwd。唯一活跃工作区可确定时为截图落盘; - // 多任务并发时只跳过本地副本,图片仍通过 MCP 返回,不阻断浏览器操作。 + // 新 Agent 直接在 tools/call._meta 携带实际 work_dir;兼容旧 Agent 时 + // 回退 session id/唯一活跃工作区。无法确定只跳过落盘,不阻断操作。 let app2 = app.clone(); - let wd: mcp::WorkdirFn = std::sync::Arc::new(move || { + let wd: mcp::WorkdirFn = std::sync::Arc::new(move |scope| { let Some(host) = app2.try_state::() else { return Err("桌面驱动尚未初始化,无法确定浏览器操作归属".into()); }; let driver = host .get() .map_err(|e| format!("无法确定浏览器操作归属:{e}"))?; - Ok(driver.single_running_workdir()) + Ok(scope + .work_dir + .clone() + .or_else(|| { + scope + .session_id + .as_deref() + .and_then(|id| driver.browser_workdir_for(id)) + }) + .or_else(|| driver.single_running_workdir())) }); match mcp::serve(mcp_sessions.clone(), wd) { Ok((url, token)) => { diff --git a/desktop/src/browser/session.rs b/desktop/src/browser/session.rs index 0fc800d6..1fca82fc 100644 --- a/desktop/src/browser/session.rs +++ b/desktop/src/browser/session.rs @@ -1,4 +1,5 @@ -// 浏览器会话现场:每个 MCP protocol session 独立持有当前标签页、ref 表、事件旁白 +// 浏览器会话现场:每个 MCP protocol + Agent session context 独立持有当前 +// 标签页、ref 表、事件旁白 // 与 CDP 交互原语;BrowserSessions 负责 tab → owner 事件路由。 // 契约对齐 agent/internal/browser/session.go(语义逐字移植)。 // @@ -33,9 +34,9 @@ use super::refs::{err_ref_stale, RefTable}; #[derive(Clone)] pub struct BrowserSession(pub(crate) Arc); -/// 进程内浏览器现场注册表。每条 MCP protocol session 取一个 -/// BrowserSession;不同 owner 可并行操作各自标签页,同一 owner 内由 MCP -/// 层串行,避免 ref/current-tab 状态互踩。 +/// 进程内浏览器现场注册表。每个 MCP protocol + Agent session context 取 +/// 一个 BrowserSession;不同 owner 可并行操作各自标签页,同一 owner 内由 +/// MCP 层串行,避免 ref/current-tab 状态互踩。 #[derive(Clone)] pub struct BrowserSessions(Arc); @@ -203,7 +204,7 @@ impl SessState { impl BrowserSession { /// 单现场兼容构造器(测试/独立使用)。生产 MCP 复用一个 - /// BrowserSessions,并按 MCP 协议会话创建 owner。 + /// BrowserSessions,并按 MCP 协议会话/Agent session 创建 owner。 #[cfg(test)] pub fn new(bridge: ExtBridge) -> Self { BrowserSessions::new(bridge).get_or_create("default") diff --git a/desktop/src/browser/tests.rs b/desktop/src/browser/tests.rs index bd399f43..f12972df 100644 --- a/desktop/src/browser/tests.rs +++ b/desktop/src/browser/tests.rs @@ -194,13 +194,13 @@ async fn mcp_smoke_initialize_list_call() { let b = ExtBridge::new(27460, &dir); // 不 spawn 桥监听:MCP 面不依赖扩展在线 let sessions = mcp::McpSessions::new(b); - let workdir_calls = std::sync::Arc::new(std::sync::atomic::AtomicUsize::new(0)); - let workdir_calls2 = workdir_calls.clone(); + let scopes: std::sync::Arc>> = Default::default(); + let scopes2 = scopes.clone(); let (url, token) = mcp::serve( sessions, - std::sync::Arc::new(move || { - workdir_calls2.fetch_add(1, std::sync::atomic::Ordering::SeqCst); - Ok(None) + std::sync::Arc::new(move |scope| { + scopes2.lock().unwrap().push(scope.clone()); + Ok(scope.work_dir.clone()) }), ) .expect("MCP 启动"); @@ -295,11 +295,25 @@ async fn mcp_smoke_initialize_list_call() { .await; assert!(resp.contains(r#""isError":true"#), "应 isError: {resp}"); assert!(resp.contains("当前没有活动标签页"), "缺可行动文案: {resp}"); - assert_eq!( - workdir_calls.load(std::sync::atomic::Ordering::SeqCst), - 1, - "标准 tools/call 应经过 Desktop 工作区解析" - ); + + // 新 Agent 发送顶层 _meta.session_id/work_dir;Desktop 必须按实际字段 + // 消费,不能沿用旧草案里的 namespace 或 cwd 拼写。 + let resp = post( + json!({ "jsonrpc": "2.0", "id": 4, "method": "tools/call", + "params": { "name": "browser_snapshot", "arguments": {}, "_meta": { + "session_id": "agent-child", "work_dir": "/workspace/child" + } } }), + Some(token.clone()), + Some(session.clone()), + ) + .await; + assert!(resp.contains(r#""isError":true"#)); + { + let seen = scopes.lock().unwrap(); + let scope = seen.last().expect("workdir resolver 应收到 scope"); + assert_eq!(scope.session_id.as_deref(), Some("agent-child")); + assert_eq!(scope.work_dir.as_deref(), Some("/workspace/child")); + } // 通知 → 202 let resp = post( @@ -332,10 +346,10 @@ async fn mcp_smoke_initialize_list_call() { assert!(resp.starts_with("HTTP/1.1 404"), "已删除会话必须失效: {resp}"); } -/// 不同 MCP transport 必须真正并行,不能只做到状态分表后仍被一个全局 -/// mutex 串行。隔离只依赖标准 Mcp-Session-Id,不要求 Agent 私有元数据。 +/// 父/子 Agent 共用一个 MCP transport;不同 _meta.session_id 必须真正并行, +/// 不能只做到状态分表后仍被 transport 级全局 mutex 串行。 #[tokio::test(flavor = "multi_thread")] -async fn mcp_protocol_sessions_execute_in_parallel() { +async fn mcp_agent_contexts_execute_in_parallel() { let dir = tmp_dir("mcp-parallel"); let sessions = mcp::McpSessions::new(ExtBridge::new(27465, &dir)); let gate = std::sync::Arc::new(( @@ -347,7 +361,7 @@ async fn mcp_protocol_sessions_execute_in_parallel() { let timed_out2 = timed_out.clone(); let (url, token) = mcp::serve( sessions, - std::sync::Arc::new(move || { + std::sync::Arc::new(move |_| { let (lock, ready) = &*gate2; let mut entered = lock.lock().unwrap(); *entered += 1; @@ -382,59 +396,47 @@ async fn mcp_protocol_sessions_execute_in_parallel() { String::from_utf8_lossy(&buf).into_owned() } - let init_one = post( + let init = post( &addr, &token, None, json!({ "jsonrpc": "2.0", "id": 1, "method": "initialize", "params": {} }), ) .await; - let session_one = init_one + let session = init .lines() .find_map(|line| line.strip_prefix("Mcp-Session-Id: ")) .map(str::trim) .expect("initialize 应返回 session id") .to_string(); - let init_two = post( - &addr, - &token, - None, - json!({ "jsonrpc": "2.0", "id": 2, "method": "initialize", "params": {} }), - ) - .await; - let session_two = init_two - .lines() - .find_map(|line| line.strip_prefix("Mcp-Session-Id: ")) - .map(str::trim) - .expect("第二个 initialize 应返回 session id") - .to_string(); - assert_ne!(session_one, session_two); let one = post( &addr, &token, - Some(&session_one), - json!({ "jsonrpc": "2.0", "id": 3, "method": "tools/call", "params": { - "name": "browser_snapshot", "arguments": {} + Some(&session), + json!({ "jsonrpc": "2.0", "id": 2, "method": "tools/call", "params": { + "name": "browser_snapshot", "arguments": {}, + "_meta": { "session_id": "agent-one", "work_dir": "/workspace/one" } } }), ); let two = post( &addr, &token, - Some(&session_two), - json!({ "jsonrpc": "2.0", "id": 4, "method": "tools/call", "params": { - "name": "browser_snapshot", "arguments": {} + Some(&session), + json!({ "jsonrpc": "2.0", "id": 3, "method": "tools/call", "params": { + "name": "browser_snapshot", "arguments": {}, + "_meta": { "session_id": "agent-two", "work_dir": "/workspace/two" } } }), ); let (one, two) = tokio::time::timeout(Duration::from_secs(5), async { tokio::join!(one, two) }) .await - .expect("不同 MCP protocol session 不应互相阻塞"); + .expect("不同 Agent context 不应互相阻塞"); assert!(one.contains(r#""isError":true"#) && two.contains(r#""isError":true"#)); - assert_eq!(*gate.0.lock().unwrap(), 2, "两个 protocol session 都应进入 resolver"); + assert_eq!(*gate.0.lock().unwrap(), 2, "两个 Agent context 都应进入 resolver"); assert!( !timed_out.load(std::sync::atomic::Ordering::SeqCst), - "两个 MCP protocol session 被全局锁串行了" + "两个 Agent context 被 transport 级锁串行了" ); } @@ -446,7 +448,7 @@ async fn mcp_gosdk_wire_shape() { let dir = tmp_dir("mcp-wire"); let b = ExtBridge::new(27470, &dir); let sessions = mcp::McpSessions::new(b); - let (url, token) = mcp::serve(sessions, std::sync::Arc::new(|| Ok(None))).expect("MCP 启动"); + let (url, token) = mcp::serve(sessions, std::sync::Arc::new(|_| Ok(None))).expect("MCP 启动"); let addr = url.strip_prefix("http://").unwrap().split('/').next().unwrap().to_string(); async fn raw(addr: &str, req: String) -> String { diff --git a/desktop/src/driver/ohmy_tests.rs b/desktop/src/driver/ohmy_tests.rs index df91a70c..705acd57 100644 --- a/desktop/src/driver/ohmy_tests.rs +++ b/desktop/src/driver/ohmy_tests.rs @@ -489,7 +489,7 @@ fn concurrent_sidecar_updates_do_not_lose_fields() { } #[test] -fn browser_workdir_fallback_does_not_reject_concurrency() { +fn browser_context_resolves_explicit_sessions_without_rejecting_concurrency() { let inner = bare_inner("browser-owner"); let mut one = bare_session("s1"); one.workdir = "/workspace/one".into(); @@ -501,6 +501,8 @@ fn browser_workdir_fallback_does_not_reject_concurrency() { sessions.insert("s2".into(), two); } let driver = OhmyDriver(inner.clone()); + assert_eq!(driver.browser_workdir_for("s1").as_deref(), Some("/workspace/one")); + assert_eq!(driver.browser_workdir_for("s2").as_deref(), Some("/workspace/two")); assert_eq!(driver.single_running_workdir(), None, "多任务时仅停用旧式落盘兜底"); inner.sess.sessions.lock().unwrap().get_mut("s2").unwrap().running = false; diff --git a/desktop/src/driver/session.rs b/desktop/src/driver/session.rs index 6f002084..a5dd3467 100644 --- a/desktop/src/driver/session.rs +++ b/desktop/src/driver/session.rs @@ -738,9 +738,19 @@ impl OhmyDriver { Ok(()) } - /// MCP 标准工具调用不带 cwd;仅在唯一 owner 可确定时返回截图落盘路径。 - /// 多 owner 时只跳过落盘,浏览器现场仍由 MCP session 隔离并正常并发, - /// 绝不因工作区不明确而拒绝工具调用。 + /// 按 Agent/壳 session id 精确查工作区。新 MCP 调用同时显式携带 + /// work_dir;本方法用于兼容元数据缺失或旧 Agent。 + pub fn browser_workdir_for(&self, id: &str) -> Option { + let sessions = self.0.sess.sessions.lock().unwrap(); + sessions + .get(id) + .or_else(|| sessions.values().find(|session| session.engine_id == id)) + .map(|session| session.workdir.clone()) + .filter(|workdir| !workdir.is_empty()) + } + + /// 旧 Agent 没有 MCP 调用元数据时的截图落盘兜底:仅在唯一 owner 可 + /// 确定时返回路径。多 owner 时只跳过落盘,浏览器现场仍正常并发。 pub fn single_running_workdir(&self) -> Option { // 显式后台 Agent 只转发 tool/error 心跳,纯文本任务可能从未物化 // child SessionState;background_agents 才是其存活/父归属真值。