@tencent-ai/cloud-agent-sdk 0.2.14-next.e4d2ba9.20260321 → 0.2.15-next.2d2b062.20260324

package/dist/index.cjs

@@ -963,6 +963,7 @@ function streamableHttp(options) {
 			const headers = buildHeaders();
 			headers["Accept"] = "text/event-stream";
 			if (lastEventId) headers["Last-Event-ID"] = lastEventId;
+			if (connectionId) headers["Acp-Connection-Id"] = connectionId;
 			const connectTimeoutMs = connectionTimeout > 0 ? connectionTimeout : 3e4;
 			const connectController = new AbortController();
 			const connectTimer = setTimeout(() => connectController.abort(), connectTimeoutMs);
@@ -1182,6 +1183,10 @@ var ArtifactManager = class {
 */
 const DEFAULT_INITIALIZE_TIMEOUT = 3e4;
 /**
+* Default timeout for session/new operation (waiting for sessionId via SSE)
+*/
+const DEFAULT_SESSION_TIMEOUT = 3e4;
+/**
 * Default timeout for permission requests
 */
 const DEFAULT_PERMISSION_TIMEOUT = 3e5;
@@ -1237,8 +1242,14 @@ var InitializationError = class extends ACPClientError {
 * Error thrown for session-related failures
 */
 var SessionError = class extends ACPClientError {
-	constructor(message, sessionId, cause) {
-		super(message, "SESSION_ERROR", cause);
+	constructor(message, sessionId, agentIdOrCause, cause) {
+		if (agentIdOrCause instanceof Error) {
+			super(message, "SESSION_ERROR", agentIdOrCause);
+			this.agentId = void 0;
+		} else {
+			super(message, "SESSION_ERROR", cause);
+			this.agentId = agentIdOrCause;
+		}
 		this.name = "SessionError";
 		this.sessionId = sessionId;
 	}
@@ -2000,16 +2011,31 @@ var StreamableHttpClient = class {
 	*
 	* Retries on transient network errors (e.g., proxy connection reset)
 	* since session/new is idempotent and safe to retry.
+	*
+	* A timeout (`options.sessionTimeout`, default 30 s) guards against the
+	* SSE response never arriving — the POST returns 202 immediately and the
+	* sessionId comes back via GET SSE, which can hang indefinitely.
+	* On timeout a `SessionError` is thrown.
 	*/
 	async createSession(cwd) {
 		this.ensureInitialized("createSession");
 		const maxRetries = 2;
+		const timeout = this.options.sessionTimeout ?? DEFAULT_SESSION_TIMEOUT;
 		let lastError;
 		for (let attempt = 0; attempt <= maxRetries; attempt++) try {
-			const response = await this.connection.newSession({
+			const sessionPromise = this.connection.newSession({
 				cwd,
 				mcpServers: []
 			});
+			let response;
+			if (timeout > 0) {
+				const timeoutPromise = new Promise((_, reject) => {
+					setTimeout(() => {
+						reject(new SessionError(`session/new timed out after ${timeout}ms`));
+					}, timeout);
+				});
+				response = await Promise.race([sessionPromise, timeoutPromise]);
+			} else response = await sessionPromise;
 			this.options.logger?.info(`Session created: ${response.sessionId}`);
 			return response;
 		} catch (err) {
@@ -18100,226 +18126,3654 @@ var CloudAgentProvider = class CloudAgentProvider {
 };
 
 //#endregion
-//#region ../agent-provider/src/common/providers/local-agent-provider/local-connection.ts
+//#region ../agent-provider/src/common/providers/local-agent-provider/acp/json-rpc.ts
 /**
-* Local Agent Connection
-* Wraps AcpJsonRpcClient to implement AgentConnection interface
+* JSON-RPC 编解码器
 *
-* Uses IWidgetChannel for IPC communication with ExtensionHost
-* Migrated from ipc-agent-provider for unified local agent access
+* 提供 JSON-RPC 2.0 消息的编码和解码功能
 */
-
-//#endregion
-//#region ../agent-provider/src/common/client/session.ts
+var JsonRpcEncoder = class {
+	/**
+	* 编码请求消息
+	* @param id 请求 ID
+	* @param method 方法名
+	* @param params 参数 (可选)
+	* @returns AcpRpcEnvelope 包装的 JSON-RPC 请求
+	*/
+	static encodeRequest(id, method, params) {
+		return {
+			type: "acp-rpc",
+			payload: {
+				jsonrpc: "2.0",
+				id,
+				method,
+				params
+			}
+		};
+	}
+	/**
+	* 编码通知消息 (无响应)
+	* @param method 方法名
+	* @param params 参数 (可选)
+	* @returns AcpRpcEnvelope 包装的 JSON-RPC 通知
+	*/
+	static encodeNotification(method, params) {
+		return {
+			type: "acp-rpc",
+			payload: {
+				jsonrpc: "2.0",
+				method,
+				params
+			}
+		};
+	}
+	/**
+	* 编码成功响应
+	* @param id 对应请求的 ID
+	* @param result 结果数据
+	* @returns AcpRpcEnvelope 包装的 JSON-RPC 响应
+	*/
+	static encodeSuccessResponse(id, result) {
+		return {
+			type: "acp-rpc",
+			payload: {
+				jsonrpc: "2.0",
+				id,
+				result
+			}
+		};
+	}
+	/**
+	* 编码错误响应
+	* @param id 对应请求的 ID
+	* @param error 错误信息
+	* @returns AcpRpcEnvelope 包装的 JSON-RPC 错误响应
+	*/
+	static encodeErrorResponse(id, error) {
+		return {
+			type: "acp-rpc",
+			payload: {
+				jsonrpc: "2.0",
+				id,
+				error
+			}
+		};
+	}
+	/**
+	* 解码 ACP RPC 消息
+	* @param envelope AcpRpcEnvelope
+	* @returns 解码后的 JSON-RPC 消息
+	* @throws 如果消息格式无效
+	*/
+	static decode(envelope) {
+		if (!this.isAcpRpcMessage(envelope)) throw new Error("Invalid ACP RPC message format");
+		const payload = envelope.payload;
+		if (typeof payload !== "object" || payload === null) throw new Error("Invalid JSON-RPC payload");
+		if (payload.jsonrpc !== "2.0") throw new Error("Invalid JSON-RPC version (must be \"2.0\")");
+		const hasId = "id" in payload;
+		const hasMethod = typeof payload.method === "string";
+		if (!hasId && !hasMethod) throw new Error("Invalid JSON-RPC message (must have id or method)");
+		return payload;
+	}
+	/**
+	* 检查是否为 ACP RPC 消息
+	* @param message 待检查的消息
+	* @returns 是否为有效的 AcpRpcEnvelope
+	*/
+	static isAcpRpcMessage(message) {
+		return typeof message === "object" && message !== null && "type" in message && message.type === "acp-rpc" && "payload" in message;
+	}
+	/**
+	* 检查是否为 JSON-RPC 请求 (有 id 字段)
+	* @param message JSON-RPC 消息
+	* @returns 是否为请求消息
+	*/
+	static isRequest(message) {
+		return "id" in message && "method" in message;
+	}
+	/**
+	* 检查是否为 JSON-RPC 响应 (有 id 字段，有 result 或 error)
+	* @param message JSON-RPC 消息
+	* @returns 是否为响应消息
+	*/
+	static isResponse(message) {
+		return "id" in message && ("result" in message || "error" in message);
+	}
+	/**
+	* 检查是否为 JSON-RPC 通知 (无 id 字段)
+	* @param message JSON-RPC 消息
+	* @returns 是否为通知消息
+	*/
+	static isNotification(message) {
+		return !("id" in message) && "method" in message;
+	}
+};
 /**
-* ActiveSessionImpl - Implements the ActiveSession interface
-*
-* This class wraps an AgentConnection and provides the session-centric API.
-* It is created by SessionManager when creating or loading sessions.
-*
-* @example
-* ```typescript
-* // Created by client.sessions.new() or client.sessions.load()
-* const session = await client.sessions.new({ cwd: '/workspace' });
-*
-* // Access agent state
-* console.log(session.agentState.status);
-*
-* // Send prompt
-* const response = await session.prompts.send({ content: 'Hello!' });
+* 请求 ID 生成器
 *
-* // Cleanup
-* session.disconnect();
-* ```
+* 格式: acp_{序号}_{时间戳}
+* 示例: acp_1_1704067200000
 */
-var ActiveSessionImpl = class {
+var RequestIdGenerator = class {
+	constructor() {
+		this.counter = 0;
+	}
 	/**
-	* Create an ActiveSessionImpl instance
-	*
-	* @param sessionId - Session ID
-	* @param agentId - Agent ID
-	* @param connection - Already connected AgentConnection
-	* @param options - Additional options
+	* 生成下一个请求 ID
+	* @returns 请求 ID 字符串
 	*/
-	constructor(sessionId, agentId, connection, options = {}) {
-		this._availableCommands = [];
-		this.listeners = /* @__PURE__ */ new Map();
-		this.onceListeners = /* @__PURE__ */ new Map();
-		this.connectionListeners = [];
-		this._id = sessionId;
-		this._agentId = agentId;
-		this.connection = connection;
-		this.logger = options.logger;
-		this._getFilesystem = options.getFilesystem;
-		this._connectionInfo = options.connectionInfo;
-		this.setupConnectionEvents(connection);
-		this.agent = this.createAgentOperations();
-		this.prompts = this.createPromptsResource();
-		this.artifacts = this.createArtifactsResource();
-		this.files = this.createFilesResource();
+	generate() {
+		return `acp_${++this.counter}`;
 	}
 	/**
-	* Session ID
+	* 重置计数器
 	*/
-	get id() {
-		return this._id;
+	reset() {
+		this.counter = 0;
+	}
+};
+
+//#endregion
+//#region ../agent-provider/src/common/providers/local-agent-provider/acp/types.ts
+/**
+* 特殊 sessionId 常量
+* 这些 sessionId 不需要路由到特定窗口
+*/
+const SPECIAL_SESSION_IDS = {
+	GLOBAL: "__global__",
+	NEW: "__new__",
+	WORKSPACE: "__workspace__",
+	BROADCAST: "__broadcast__"
+};
+/**
+* 检查是否为保留 sessionId
+* @param sessionId 会话 ID
+* @returns 是否为保留 sessionId
+*/
+function isReservedSessionId(sessionId) {
+	return Object.values(SPECIAL_SESSION_IDS).includes(sessionId) && sessionId !== SPECIAL_SESSION_IDS.BROADCAST;
+}
+
+//#endregion
+//#region ../agent-provider/src/common/providers/local-agent-provider/acp/acp-json-rpc-client.ts
+/**
+* ACP JSON-RPC Client 实现
+*
+* 实现 IAcpJsonRpcClient 接口
+*/
+var AcpJsonRpcClient = class {
+	constructor(channel, config = {}) {
+		this.requestIdGenerator = new RequestIdGenerator();
+		this.pendingRequests = /* @__PURE__ */ new Map();
+		this.sessionUpdateCallbacks = /* @__PURE__ */ new Set();
+		this.permissionRequestResolvers = /* @__PURE__ */ new Map();
+		this.extNotificationCallbacks = /* @__PURE__ */ new Set();
+		this.eventHandlers = [];
+		this.channel = channel;
+		this.debug = true;
+		this.setupMessageListener();
+		this.log("AcpJsonRpcClient initialized");
+	}
+	async initialize(request) {
+		this.log("initialize called");
+		return await this.sendRequest(SPECIAL_SESSION_IDS.GLOBAL, "initialize", request);
+	}
+	async authenticate(request) {
+		this.log("authenticate called");
+		await this.sendRequest(SPECIAL_SESSION_IDS.GLOBAL, "authenticate", request);
+	}
+	async newSession(request) {
+		this.log("newSession called");
+		return await this.sendRequest(SPECIAL_SESSION_IDS.NEW, "newSession", request);
+	}
+	async loadSession(request) {
+		this.log(`[AcpJsonRpcClient] loadSession called:, ${request.sessionId}`);
+		const response = await this.sendRequest(request.sessionId, "loadSession", request);
+		this.log(`[AcpJsonRpcClient] loadSession response:, ${response}`);
+		return response;
+	}
+	async prompt(request) {
+		this.log("prompt called for session:", request.sessionId);
+		return await this.sendRequest(request.sessionId, "prompt", request);
+	}
+	async cancel(params) {
+		this.log("cancel called for session:", params.sessionId);
+		const envelope = JsonRpcEncoder.encodeNotification("cancel", params);
+		this.send(params.sessionId, envelope);
+	}
+	async setSessionModel(params) {
+		this.log("setSessionModel called for session:", params.sessionId);
+		return await this.sendRequest(params.sessionId, "setSessionModel", params);
+	}
+	async setSessionMode(params) {
+		this.log("setSessionMode called for session:", params.sessionId);
+		return await this.sendRequest(params.sessionId, "setSessionMode", params);
+	}
+	async toolCallback(request) {
+		this.log("toolCallback called for session:", request.sessionId, "action:", request.action);
+		return await this.sendRequest(request.sessionId, "toolCallback", request);
 	}
 	/**
-	* Agent ID
+	* 打开工作区窗口
+	* 使用 __workspace__ session ID，由 Main Process 直接处理
+	* @param request 打开工作区请求
+	* @returns 打开工作区响应
 	*/
-	get agentId() {
-		return this._agentId;
+	async openWorkspace(request) {
+		this.log("openWorkspace called", request);
+		return await this.sendRequest(SPECIAL_SESSION_IDS.WORKSPACE, "openWorkspace", request);
 	}
 	/**
-	* Actual workspace path (set from newSession response _meta)
+	* 发送全局请求
+	* 使用 __global__ session ID，会根据 params.cwd 路由到对应窗口
+	* cwd 为空时会路由到 Default Window
+	* @param method 方法名
+	* @param params 请求参数
+	* @returns 响应结果
 	*/
-	get cwd() {
-		return this._cwd;
+	async sendBroadcastRequest(method, params) {
+		this.log(`sendGlobalRequest called: ${method}`, params);
+		return await this.sendRequest(SPECIAL_SESSION_IDS.BROADCAST, method, params);
 	}
 	/**
-	* Set actual workspace path (called by SessionManager after createSession)
+	* 获取当前工作区列表
+	* 使用 __workspace__ session ID，由 Main Process 直接处理
+	* @param request 获取工作区列表请求
+	* @returns 获取工作区列表响应
 	*/
-	setCwd(cwd) {
-		this._cwd = cwd;
+	async getCurrentWorkspaces(request) {
+		this.log("getCurrentWorkspaces called", request);
+		return await this.sendRequest(SPECIAL_SESSION_IDS.WORKSPACE, "getCurrentWorkspaces", request ?? {});
 	}
 	/**
-	* Agent state (live connection state)
-	* Returns LocalAgentState or CloudAgentState based on transport type
+	* 获取已安装插件列表
+	* 使用 __broadcast__ session ID，由 Extension Host 处理
+	* @param request 获取插件请求
+	* @returns 已安装插件列表响应
 	*/
-	get agentState() {
-		return {
-			id: this._agentId,
-			status: this.connection.state,
-			capabilities: this.connection.capabilities,
-			type: this.connection.transport,
-			cwd: this.connection.cwd || ""
-		};
+	async getInstalledPlugins(request) {
+		this.log("getInstalledPlugins called", request);
+		return await this.sendRequest(SPECIAL_SESSION_IDS.BROADCAST, "getInstalledPlugins", request ?? {});
 	}
 	/**
-	* Get agent capabilities (available after connection)
+	* 安装插件
+	* 使用 __broadcast__ session ID，由 Extension Host 处理
+	* @param request 安装插件请求
+	* @returns 安装结果
 	*/
-	get capabilities() {
-		return this.connection.capabilities;
+	async installPlugins(request) {
+		this.log("installPlugins called", request);
+		return await this.sendRequest(SPECIAL_SESSION_IDS.BROADCAST, "installPlugins", request);
 	}
 	/**
-	* Available session modes
+	* 卸载插件
+	* 使用 __broadcast__ session ID，由 Extension Host 处理
+	* @param request 卸载插件请求
+	* @returns 卸载结果
 	*/
-	get availableModes() {
-		return this._availableModes;
+	async uninstallPlugin(request) {
+		this.log("uninstallPlugin called", request);
+		return await this.sendRequest(SPECIAL_SESSION_IDS.BROADCAST, "uninstallPlugin", request);
 	}
 	/**
-	* Current session mode
+	* 更新插件到最新版本
+	* 使用 __broadcast__ session ID，由 Extension Host 处理
+	* @param request 更新插件请求
+	* @returns 更新结果
 	*/
-	get currentMode() {
-		return this._currentMode;
+	async updatePlugin(request) {
+		this.log("updatePlugin called", request);
+		return await this.sendRequest(SPECIAL_SESSION_IDS.BROADCAST, "updatePlugin", request);
 	}
 	/**
-	* Available models for this session
+	* 批量切换插件状态
+	* 使用 __broadcast__ session ID，由 Extension Host 处理
+	* @param request 批量切换插件请求
+	* @returns 批量操作结果
 	*/
-	get availableModels() {
-		return this._availableModels;
+	async batchTogglePlugins(request) {
+		this.log("batchTogglePlugins called", request);
+		return await this.sendRequest(SPECIAL_SESSION_IDS.BROADCAST, "batchTogglePlugins", request);
 	}
 	/**
-	* Current model ID
+	* 获取插件市场列表
+	* 使用 __broadcast__ session ID，由 Extension Host 处理
+	* @param request 获取市场列表请求
+	* @returns 插件市场列表响应
 	*/
-	get currentModelId() {
-		return this._currentModelId;
+	async getPluginMarketplaces(request) {
+		this.log("getPluginMarketplaces called", request);
+		return await this.sendRequest(SPECIAL_SESSION_IDS.BROADCAST, "getPluginMarketplaces", request ?? {});
 	}
 	/**
-	* Available slash commands
-	*
-	* When Agent sends available_commands_update, this list is automatically updated.
-	* Commands can be accessed directly without waiting for events.
+	* 获取市场下的插件列表
+	* 使用 __broadcast__ session ID，由 Extension Host 处理
+	* @param request 获取市场插件请求
+	* @returns 市场插件列表响应
 	*/
-	get availableCommands() {
-		return this._availableCommands;
+	async getMarketplacePlugins(request) {
+		this.log("getMarketplacePlugins called", request);
+		return await this.sendRequest(SPECIAL_SESSION_IDS.BROADCAST, "getMarketplacePlugins", request);
 	}
 	/**
-	* Set available commands (called when available_commands_update is received)
+	* 获取插件详情
+	* 使用 __broadcast__ session ID，由 Extension Host 处理
+	* @param request 获取插件详情请求
+	* @returns 插件详情响应
 	*/
-	setAvailableCommands(commands) {
-		this._availableCommands = commands;
-		this.logger?.info(`Session ${this._id}: Available commands updated, count: ${commands.length}`);
+	async getPluginDetail(request) {
+		this.log("getPluginDetail called", request);
+		return await this.sendRequest(SPECIAL_SESSION_IDS.BROADCAST, "getPluginDetail", request);
 	}
 	/**
-	* Check if the session is active
+	* 添加插件市场
+	* 使用 __broadcast__ session ID，由 Extension Host 处理
+	* @param request 添加市场请求
+	* @returns 添加结果
 	*/
-	get isActive() {
-		return this.connection.isInitialized;
+	async addPluginMarketplace(request) {
+		this.log("addPluginMarketplace called", request);
+		return await this.sendRequest(SPECIAL_SESSION_IDS.BROADCAST, "addPluginMarketplace", request);
 	}
 	/**
-	* Session connection information (only available for cloud sessions)
-	* 会话连接信息，包括sandboxId、link、token等
+	* 删除插件市场
+	* 使用 __broadcast__ session ID，由 Extension Host 处理
+	* @param request 删除市场请求
+	* @returns 删除结果
 	*/
-	get connectionInfo() {
-		return this._connectionInfo;
+	async removePluginMarketplace(request) {
+		this.log("removePluginMarketplace called", request);
+		return await this.sendRequest(SPECIAL_SESSION_IDS.BROADCAST, "removePluginMarketplace", request);
 	}
 	/**
-	* Set session modes (called after create/load)
+	* 刷新插件市场
+	* 使用 __broadcast__ session ID，由 Extension Host 处理
+	* @param request 刷新市场请求
+	* @returns 刷新结果
 	*/
-	setModes(availableModes, currentMode) {
-		this._availableModes = availableModes;
-		this._currentMode = currentMode;
+	async refreshPluginMarketplace(request) {
+		this.log("refreshPluginMarketplace called", request);
+		return await this.sendRequest(SPECIAL_SESSION_IDS.BROADCAST, "refreshPluginMarketplace", request);
 	}
 	/**
-	* Set available models (called after create/load)
+	* 用新窗口打开文件夹
+	* 使用 __broadcast__ session ID，由 Extension Host 处理
+	*
+	* @param request 打开文件夹请求
 	*/
-	setModels(availableModels, currentModelId) {
-		this._availableModels = availableModels;
-		this._currentModelId = currentModelId;
+	async openFolderInNewWindow(request) {
+		this.log("openFolderInNewWindow called", request);
+		await this.sendRequest(SPECIAL_SESSION_IDS.BROADCAST, "openFolderInNewWindow", request);
 	}
-	createAgentOperations() {
-		const self = this;
-		return {
-			get id() {
-				return self._agentId;
-			},
-			get state() {
-				return self.agentState;
-			},
-			get isConnected() {
-				return self.connection.isInitialized;
-			},
-			get capabilities() {
-				return self.connection.capabilities;
-			}
+	/**
+	* 获取支持的场景列表（从后端 API）
+	* 使用 __broadcast__ session ID，由 Extension Host 处理
+	* 用于 Welcome 页面的 QuickActions 快捷操作
+	*
+	* 调用链：
+	* 1. AgentNewAdapter.getTemplates() 调用此方法
+	* 2. 通过 ACP 协议发送请求到 Extension Host
+	* 3. Extension Host 调用 RestOperations -> GET /v2/as/support/scenes
+	* 4. 返回 SupportSceneInfo[] 数据
+	*
+	* @param request 获取支持场景请求
+	* @returns 支持的场景列表响应
+	*/
+	async getSupportScenes(request) {
+		this.log("getSupportScenes called", request);
+		return await this.sendRequest(SPECIAL_SESSION_IDS.BROADCAST, "getSupportScenes", request ?? {});
+	}
+	getAutomationBridge() {
+		return globalThis.__codebuddyAutomationBridge;
+	}
+	requireAutomationBridge() {
+		const bridge = this.getAutomationBridge();
+		if (!bridge) throw new Error("Automation bridge is unavailable; automation now only supports the Main/Renderer orchestration path");
+		return bridge;
+	}
+	async getAutomationSnapshot() {
+		this.log("getAutomationSnapshot called");
+		const bridge = this.requireAutomationBridge();
+		if (!bridge.getAutomationSnapshot) throw new Error("Automation bridge does not implement getAutomationSnapshot");
+		return await bridge.getAutomationSnapshot();
+	}
+	async updateAutomation(request) {
+		this.log("updateAutomation called", request);
+		const bridge = this.requireAutomationBridge();
+		if (!bridge.updateAutomation) throw new Error("Automation bridge does not implement updateAutomation");
+		return await bridge.updateAutomation(request);
+	}
+	async deleteAutomation(request) {
+		this.log("deleteAutomation called", request);
+		const bridge = this.requireAutomationBridge();
+		if (!bridge.deleteAutomation) throw new Error("Automation bridge does not implement deleteAutomation");
+		return await bridge.deleteAutomation(request.id);
+	}
+	async archiveAutomationInboxItem(request) {
+		this.log("archiveAutomationInboxItem called", request);
+		const bridge = this.requireAutomationBridge();
+		if (!bridge.archiveAutomationInboxItem) throw new Error("Automation bridge does not implement archiveAutomationInboxItem");
+		return await bridge.archiveAutomationInboxItem(request.itemId);
+	}
+	async deleteAutomationInboxItem(request) {
+		this.log("deleteAutomationInboxItem called", request);
+		const bridge = this.requireAutomationBridge();
+		if (!bridge.deleteAutomationInboxItem) throw new Error("Automation bridge does not implement deleteAutomationInboxItem");
+		return await bridge.deleteAutomationInboxItem(request.itemId);
+	}
+	async testAutomation(request) {
+		this.log("testAutomation called", request);
+		const bridge = this.requireAutomationBridge();
+		if (!bridge.testAutomation) throw new Error("Automation bridge does not implement testAutomation");
+		return await bridge.testAutomation(request.id);
+	}
+	onSessionUpdate(callback) {
+		this.sessionUpdateCallbacks.add(callback);
+		this.log("onSessionUpdate: callback registered");
+		return () => {
+			this.sessionUpdateCallbacks.delete(callback);
+			this.log("onSessionUpdate: callback unregistered");
 		};
 	}
-	createPromptsResource() {
-		return {
-			send: async (params) => {
-				const response = await this.getConnectionOrThrow().prompt(this._id, params);
-				return this.mapPromptResponse(response);
-			},
-			stream: (params) => {
-				return this.getConnectionOrThrow().promptStream(this._id, params);
-			},
-			cancel: async () => {
-				await this.getConnectionOrThrow().cancel(this._id);
-			}
+	onRequestPermission(sessionId, callback) {
+		this.permissionRequestResolvers.set(sessionId, callback);
+		this.log("onRequestPermission: callback registered");
+		return () => {
+			this.permissionRequestResolvers.delete(sessionId);
+			this.log("onRequestPermission: callback unregistered");
 		};
 	}
-	createArtifactsResource() {
-		const notSupported = () => {
-			throw new Error("Artifact management is no longer supported through this API");
-		};
-		return {
-			list: async (_params) => {
-				notSupported();
-				return [];
-			},
-			retrieve: async (_artifactId) => {
-				notSupported();
-			},
-			content: async (_artifactId) => {
-				notSupported();
-				return "";
-			}
+	/**
+	* 监听 extNotification 推送
+	* 用于接收 artifact 等扩展通知
+	*/
+	onExtNotification(callback) {
+		this.extNotificationCallbacks.add(callback);
+		this.log("onExtNotification: callback registered");
+		return () => {
+			this.extNotificationCallbacks.delete(callback);
+			this.log("onExtNotification: callback unregistered");
 		};
 	}
-	/**
-	* Create files resource with lazy-loaded filesystem
-	*
+	destroy() {
+		this.log("Destroying AcpJsonRpcClient");
+		this.eventHandlers.forEach(({ event, handler }) => {
+			this.channel.off(event, handler);
+		});
+		this.eventHandlers.length = 0;
+		this.pendingRequests.forEach(({ reject }) => {
+			reject(/* @__PURE__ */ new Error("Client destroyed"));
+		});
+		this.pendingRequests.clear();
+		this.sessionUpdateCallbacks.clear();
+		this.permissionRequestResolvers.clear();
+	}
+	/**
+	* 发送 JSON-RPC 请求并等待响应
+	* @param sessionId 会话 ID
+	* @param method 方法名
+	* @param params 参数
+	* @returns Promise<T> 响应结果
+	*/
+	async sendRequest(sessionId, method, params) {
+		const id = this.requestIdGenerator.generate();
+		const envelope = JsonRpcEncoder.encodeRequest(id, method, {
+			sessionId: isReservedSessionId(sessionId) ? void 0 : sessionId,
+			...params ?? {}
+		});
+		return new Promise(async (resolve, reject) => {
+			this.pendingRequests.set(id, {
+				resolve,
+				reject,
+				method,
+				sessionId
+			});
+			if (!await this.send(sessionId, envelope)) {
+				this.pendingRequests.delete(id);
+				reject(/* @__PURE__ */ new Error(`Failed to send ${method} request for session: ${sessionId}`));
+			}
+			this.log(`Request sent: ${method} (id: ${id}, session: ${sessionId})`);
+		});
+	}
+	/**
+	* 发送消息到指定 session
+	* @param sessionId 会话 ID
+	* @param envelope ACP RPC 消息包装
+	* @returns 是否发送成功
+	*/
+	send(sessionId, envelope) {
+		return this.channel.sendNotification(sessionId, envelope);
+	}
+	/**
+	* 设置消息监听器
+	* 处理来自 ExtensionHost 的 JSON-RPC 响应和推送
+	*/
+	setupMessageListener() {
+		const responseHandler = (data) => {
+			if (!JsonRpcEncoder.isAcpRpcMessage(data)) return;
+			try {
+				const message = JsonRpcEncoder.decode(data);
+				if (JsonRpcEncoder.isResponse(message)) this.handleResponse(message);
+				else if (JsonRpcEncoder.isNotification(message)) this.handleNotification(message);
+				else if (JsonRpcEncoder.isRequest(message)) this.handleNotification(message);
+			} catch (error) {
+				this.log("Error handling message:", error);
+			}
+		};
+		this.channel.on("acp-rpc-response", responseHandler);
+		this.eventHandlers.push({
+			event: "acp-rpc-response",
+			handler: responseHandler
+		});
+		this.channel.on("message", responseHandler);
+		this.eventHandlers.push({
+			event: "message",
+			handler: responseHandler
+		});
+		this.log("Message listener setup complete");
+	}
+	/**
+	* 处理 JSON-RPC 响应
+	*/
+	handleResponse(response) {
+		const pending = this.pendingRequests.get(response.id);
+		if (!pending) {
+			this.log(`No pending request found for response id: ${response.id}`);
+			return;
+		}
+		this.pendingRequests.delete(response.id);
+		if (response.error) {
+			const error = new Error(response.error.message);
+			error.code = response.error.code;
+			pending.reject(error);
+		} else pending.resolve(response.result);
+		this.log(`Response received for request: ${pending.method} (id: ${response.id})`);
+	}
+	/**
+	* 处理 JSON-RPC 推送消息
+	*/
+	handleNotification(notification) {
+		const method = notification.method;
+		let params = notification.params;
+		if (notification.id) params = {
+			...params,
+			requestId: notification.id
+		};
+		this.log(`Notification received: ${method}`);
+		switch (method) {
+			case "session/update":
+			case "sessionUpdate":
+				this.handleSessionUpdate(params);
+				break;
+			case "request/permission":
+			case "requestPermission":
+				this.handlePermissionRequest(params);
+				break;
+			case "extNotification":
+				this.handleExtNotification(params);
+				break;
+			default: this.log(`Unknown notification method: ${method}`);
+		}
+	}
+	/**
+	* 处理 extNotification 推送
+	*/
+	handleExtNotification(params) {
+		if (!params) {
+			this.log("extNotification missing params");
+			return;
+		}
+		const method = params.method;
+		const extParams = params.params || {};
+		this.log("handleExtNotification:", {
+			method,
+			extParams
+		});
+		this.extNotificationCallbacks.forEach((callback) => {
+			try {
+				callback(method, extParams);
+			} catch (error) {
+				this.log("extNotification callback error:", error);
+			}
+		});
+	}
+	/**
+	* 处理会话更新推送
+	*
+	* 支持 ACP 协议定义的多种 session update 类型：
+	* - available_commands_update: 可用命令列表更新
+	* - 其他类型: 原样转发给调用方
+	*/
+	handleSessionUpdate(params) {
+		if (!params) {
+			this.log("Session update notification missing params");
+			return;
+		}
+		const sessionId = params.sessionId;
+		const messageId = params.messageId;
+		if (!sessionId) {
+			this.log("Invalid session update params:", params);
+			return;
+		}
+		const update = params.update;
+		if (update?.sessionUpdate === "available_commands_update") {
+			this.log(`Available commands update received for session: ${sessionId}`);
+			const rawCommands = update?.availableCommands;
+			if (Array.isArray(rawCommands)) {
+				const commands = rawCommands.filter((cmd) => cmd !== null && typeof cmd === "object" && typeof cmd.name === "string").map((cmd) => ({
+					name: String(cmd.name),
+					description: typeof cmd.description === "string" ? cmd.description : "",
+					input: cmd.input && typeof cmd.input === "object" ? { hint: typeof cmd.input.hint === "string" ? cmd.input.hint : void 0 } : void 0
+				}));
+				this.log(`Parsed ${commands.length} available commands`);
+			} else this.log("Invalid availableCommands format in available_commands_update");
+		}
+		const sessionUpdateParams = {
+			notification: params,
+			...messageId && { messageId }
+		};
+		if (this.sessionUpdateCallbacks.size === 0) this.log(`handleSessionUpdate: no callbacks registered (expected for sharedAcpClient), type=${update?.sessionUpdate}, sessionId=${sessionId?.substring(0, 8)}`);
+		this.sessionUpdateCallbacks.forEach((callback) => {
+			try {
+				callback(sessionUpdateParams);
+			} catch (error) {
+				this.log("Session update callback error:", error);
+			}
+		});
+	}
+	/**
+	* 处理权限请求推送
+	*/
+	async handlePermissionRequest(params) {
+		if (!params) {
+			this.log("Permission request notification missing params");
+			return;
+		}
+		const sessionId = params.sessionId;
+		const requestId = params.requestId;
+		const toolCall = params.toolCall;
+		const options = params.options;
+		if (!sessionId || !requestId || !toolCall) {
+			this.log("Invalid permission request params:", params);
+			return;
+		}
+		const permissionParams = {
+			sessionId,
+			requestId,
+			toolCall,
+			options
+		};
+		const resolver = this.permissionRequestResolvers.get(sessionId);
+		if (!resolver) {
+			this.log("No permission resolver registered, cancelling...");
+			return;
+		}
+		try {
+			const outcome = await resolver(permissionParams);
+			this.sendPermissionResponse(sessionId, requestId, outcome);
+		} catch (error) {
+			this.log("Permission resolver error:", error);
+			this.sendPermissionResponse(sessionId, requestId, { outcome: "cancelled" });
+		}
+	}
+	/**
+	* 发送权限响应
+	*/
+	sendPermissionResponse(sessionId, requestId, outcome) {
+		const envelope = JsonRpcEncoder.encodeSuccessResponse(requestId, outcome);
+		this.send(sessionId, envelope);
+		this.log("Permission response sent for request:", requestId);
+	}
+	/**
+	* 调试日志
+	*/
+	log(...args) {
+		if (this.debug) console.log("[AcpJsonRpcClient]", ...args);
+	}
+};
+
+//#endregion
+//#region ../agent-provider/src/common/providers/local-agent-provider/local-connection.ts
+/**
+* Local Agent Connection
+* Wraps AcpJsonRpcClient to implement AgentConnection interface
+*
+* Uses IWidgetChannel for IPC communication with ExtensionHost
+* Migrated from ipc-agent-provider for unified local agent access
+*/
+/**
+* Local Agent Connection implementation
+* Uses AcpJsonRpcClient to communicate with ExtensionHost via IWidgetChannel
+*
+* Phase 1 Implementation:
+* - connect/disconnect: ✅ via initialize
+* - createSession/loadSession: ✅ via AcpJsonRpcClient
+* - prompt/cancel: ✅ via AcpJsonRpcClient
+* - Event forwarding: ✅ sessionUpdate, permissionRequest
+* - resolvePermission/rejectPermission: ✅ via callback
+*
+* Phase 2 (Not Implemented):
+* - promptStream: throws 'Not implemented'
+* - Artifact methods: return empty
+* - Question methods: return empty
+* - Extension methods: throw 'Not implemented'
+* - Filesystem methods: throw 'Not implemented'
+*/
+var LocalAgentConnection = class {
+	constructor(agentId, config) {
+		this.listeners = /* @__PURE__ */ new Map();
+		this.onceListeners = /* @__PURE__ */ new Map();
+		this._state = "disconnected";
+		this._isInitialized = false;
+		this.pendingPermissions = /* @__PURE__ */ new Map();
+		this.artifactCache = /* @__PURE__ */ new Map();
+		this.transport = "local";
+		this.onRequest = void 0;
+		this.agentId = agentId;
+		this.cwd = agentId;
+		this.debug = config.debug ?? false;
+		this.permissionTimeout = config.permissionTimeout ?? 3e4;
+		this.permissionAutoRejectOnTimeout = config.permissionAutoRejectOnTimeout ?? false;
+		this.acpClient = new AcpJsonRpcClient(config.channel, {
+			timeoutMs: config.acpConfig?.timeoutMs ?? 3e4,
+			debug: this.debug
+		});
+		this.setupEventForwarding();
+		this.log("LocalAgentConnection initialized");
+	}
+	setupEventForwarding() {
+		this.acpClient.onSessionUpdate((params) => {
+			this.emit("sessionUpdate", params.notification);
+		});
+		this.acpClient.onExtNotification((method, params) => {
+			console.log("[LocalConnection] Received extNotification:", {
+				method,
+				paramsKeys: Object.keys(params)
+			});
+			if (method === "_codebuddy.ai/artifact") {
+				const event = params.event;
+				const artifact = params.artifact;
+				const notificationSessionId = params.sessionId;
+				if (artifact?.uri) {
+					if (event === "created" || event === "updated") this.artifactCache.set(artifact.uri, artifact);
+					else if (event === "deleted") this.artifactCache.delete(artifact.uri);
+				}
+				if (artifact && notificationSessionId) artifact.__sessionId = notificationSessionId;
+				if (event === "created") this.emit("artifactCreated", artifact);
+				else if (event === "updated") this.emit("artifactUpdated", artifact);
+				else if (event === "deleted") this.emit("artifactDeleted", artifact);
+			}
+			if (method === "_codebuddy.ai/checkpoint") {
+				const event = params.event;
+				const checkpoint = params.checkpoint;
+				const checkpointSessionId = params.sessionId;
+				console.log("[LocalConnection] Emitting checkpoint event:", {
+					event,
+					checkpointId: checkpoint?.id,
+					checkpointSessionId,
+					filesCount: checkpoint?.fileChanges?.files?.length ?? 0
+				});
+				if (checkpoint && checkpointSessionId) checkpoint.__sessionId = checkpointSessionId;
+				if (event === "created") this.emit("checkpointCreated", checkpoint);
+				else if (event === "updated") this.emit("checkpointUpdated", checkpoint);
+			}
+			if (method === ExtensionMethod.COMMAND) {
+				const action = params.action;
+				const commandParams = params.params;
+				const commandSessionId = params.sessionId;
+				console.log("[LocalConnection] Emitting command event:", {
+					action,
+					commandSessionId,
+					paramsKeys: commandParams ? Object.keys(commandParams) : []
+				});
+				const commandData = {
+					action,
+					params: commandParams
+				};
+				if (commandSessionId) commandData.__sessionId = commandSessionId;
+				this.emit("command", commandData);
+			}
+		});
+		this.log("Event forwarding setup complete");
+	}
+	on(event, listener) {
+		if (!this.listeners.has(event)) this.listeners.set(event, /* @__PURE__ */ new Set());
+		this.listeners.get(event).add(listener);
+		return this;
+	}
+	off(event, listener) {
+		const eventListeners = this.listeners.get(event);
+		if (eventListeners) eventListeners.delete(listener);
+		const onceEventListeners = this.onceListeners.get(event);
+		if (onceEventListeners) onceEventListeners.delete(listener);
+		return this;
+	}
+	once(event, listener) {
+		if (!this.onceListeners.has(event)) this.onceListeners.set(event, /* @__PURE__ */ new Set());
+		this.onceListeners.get(event).add(listener);
+		return this;
+	}
+	emit(event, data) {
+		const regularListeners = this.listeners.get(event);
+		const onceEventListeners = this.onceListeners.get(event);
+		if (event === "sessionUpdate") {
+			const updateType = data?.update?.sessionUpdate;
+			const notifSessionId = data?.sessionId;
+			if ((regularListeners?.size ?? 0) + (onceEventListeners?.size ?? 0) === 0) console.warn(`[RT-DEBUG][LocalConn] emit sessionUpdate NO LISTENERS: type=${updateType}, sessionId=${notifSessionId?.substring(0, 8)}, cwd=${this.cwd?.substring(this.cwd.length - 20)}`);
+		}
+		let hasListeners = false;
+		if (regularListeners && regularListeners.size > 0) {
+			hasListeners = true;
+			for (const listener of regularListeners) try {
+				const result = listener(data);
+				if (result instanceof Promise) result.catch((err) => {
+					console.error(`Error in async event listener for '${String(event)}':`, err);
+				});
+			} catch (err) {
+				console.error(`Error in event listener for '${String(event)}':`, err);
+			}
+		}
+		if (onceEventListeners && onceEventListeners.size > 0) {
+			hasListeners = true;
+			const listenersToCall = Array.from(onceEventListeners);
+			this.onceListeners.delete(event);
+			for (const listener of listenersToCall) try {
+				const result = listener(data);
+				if (result instanceof Promise) result.catch((err) => {
+					console.error(`Error in async once event listener for '${String(event)}':`, err);
+				});
+			} catch (err) {
+				console.error(`Error in once event listener for '${String(event)}':`, err);
+			}
+		}
+		return hasListeners;
+	}
+	removeAllListeners(event) {
+		if (event !== void 0) {
+			this.listeners.delete(event);
+			this.onceListeners.delete(event);
+		} else {
+			this.listeners.clear();
+			this.onceListeners.clear();
+		}
+		return this;
+	}
+	get state() {
+		return this._state;
+	}
+	get isInitialized() {
+		return this._isInitialized;
+	}
+	get capabilities() {
+		return this._capabilities;
+	}
+	get initializeResult() {
+		return this._initializeResult;
+	}
+	async connect(_clientCapabilities) {
+		this.log("Connecting...");
+		this._state = "connecting";
+		this.emit("connecting", void 0);
+		this._isInitialized = true;
+		this._initializeResult = { protocolVersion: _agentclientprotocol_sdk.PROTOCOL_VERSION };
+		this.emit("connected", void 0);
+		this._state = "initialized";
+		return this._initializeResult;
+	}
+	disconnect() {
+		this.log("Disconnecting...");
+		this.cleanupPendingPermissionsOnDisconnect();
+		this._state = "disconnected";
+		this._isInitialized = false;
+		this.acpClient.destroy();
+		this.emit("disconnected", void 0);
+		this.log("Disconnected");
+	}
+	/**
+	* 清理断开连接时所有待处理的权限请求
+	* 在连接断开时主动清理所有 pending 权限请求并返回 cancelled
+	*/
+	cleanupPendingPermissionsOnDisconnect() {
+		const count = this.pendingPermissions.size;
+		if (count === 0) return;
+		for (const [requestId] of this.pendingPermissions) {
+			const resolver = this[`_permissionResolver_${requestId}`];
+			if (resolver) {
+				resolver({ outcome: "cancelled" });
+				delete this[`_permissionResolver_${requestId}`];
+			}
+		}
+		this.pendingPermissions.clear();
+		this.log(`Cleaned up ${count} pending permission request(s) on disconnect`);
+	}
+	async createSession(params) {
+		this.log("Creating session with cwd:", params.cwd, params._meta);
+		const response = await this.acpClient.newSession({
+			_meta: params._meta,
+			cwd: params.cwd,
+			mcpServers: params.mcpServers ?? []
+		});
+		this.bindPermissionRequest(response.sessionId);
+		return response;
+	}
+	async loadSession(params) {
+		if (!params.sessionId) throw new Error("sessionId is required for loadSession");
+		this.log(`[LocalAgentConnection] loadSession: ${params.sessionId}`);
+		const response = await this.acpClient.loadSession({
+			sessionId: params.sessionId,
+			cwd: params.cwd,
+			mcpServers: params.mcpServers ?? []
+		});
+		this.log(`[LocalAgentConnection] loadSession response:${response}`);
+		this.bindPermissionRequest(params.sessionId);
+		return response;
+	}
+	async bindPermissionRequest(sessionId) {
+		if (this.onRequest) this.onRequest();
+		this.onRequest = this.acpClient.onRequestPermission(sessionId, async (params) => {
+			this.pendingPermissions.set(params.requestId, {
+				params,
+				createdAt: Date.now()
+			});
+			const permissionRequest = {
+				sessionId: params.sessionId,
+				toolCall: params.toolCall,
+				options: params.options
+			};
+			this.emit("permissionRequest", {
+				requestId: params.requestId,
+				params: permissionRequest
+			});
+			return new Promise((resolve) => {
+				const checkResolution = () => {
+					if (!this.pendingPermissions.has(params.requestId)) return;
+					const pending = this.pendingPermissions.get(params.requestId);
+					if (pending && Date.now() - pending.createdAt > this.permissionTimeout) {
+						this.pendingPermissions.delete(params.requestId);
+						this.emit("permissionTimeout", { requestId: params.requestId });
+						if (this.permissionAutoRejectOnTimeout) resolve({ outcome: "cancelled" });
+					}
+				};
+				this[`_permissionResolver_${params.requestId}`] = resolve;
+				setTimeout(checkResolution, this.permissionTimeout);
+			});
+		});
+	}
+	async setSessionMode(sessionId, modeId) {
+		this.log("Setting session mode:", sessionId, "to", modeId);
+		return await this.acpClient.setSessionMode({
+			sessionId,
+			modeId
+		});
+	}
+	async setSessionModel(sessionId, modelId) {
+		this.log("Setting session model:", sessionId, "to", modelId);
+		return await this.acpClient.setSessionModel({
+			sessionId,
+			modelId
+		});
+	}
+	/**
+	* 打开工作区窗口
+	* 使用 __workspace__ session ID，由 Main Process 直接处理，不转发到 ExtensionHost
+	* @param params 打开工作区请求参数
+	* @returns 打开工作区响应
+	*/
+	async openWorkspace(params) {
+		this.log("Opening workspace:", params.cwd);
+		return await this.acpClient.openWorkspace(params);
+	}
+	async prompt(sessionId, params) {
+		const prompt = typeof params.content === "string" ? [{
+			type: "text",
+			text: params.content
+		}] : params.content;
+		this.log("Sending prompt to session:", sessionId);
+		return await this.acpClient.prompt({
+			sessionId,
+			prompt,
+			_meta: {
+				...params._meta,
+				planMode: params.planMode
+			}
+		});
+	}
+	async *promptStream(_sessionId, _params) {
+		throw new Error("promptStream not implemented for Local connection");
+	}
+	async cancel(sessionId) {
+		this.log("Cancelling session:", sessionId);
+		await this.acpClient.cancel({ sessionId });
+	}
+	getArtifacts() {
+		return new Map(this.artifactCache);
+	}
+	getArtifact(uri) {
+		return this.artifactCache.get(uri);
+	}
+	getArtifactsByType(type) {
+		return Array.from(this.artifactCache.values()).filter((artifact) => artifact.type === type);
+	}
+	async fetchArtifactContent(_artifact) {
+		throw new Error("fetchArtifactContent not implemented for Local connection");
+	}
+	async fetchArtifactContentById(_id) {
+		throw new Error("fetchArtifactContentById not implemented for Local connection");
+	}
+	resolvePermission(requestId, optionId) {
+		const resolver = this[`_permissionResolver_${requestId}`];
+		if (resolver) {
+			this.pendingPermissions.delete(requestId);
+			delete this[`_permissionResolver_${requestId}`];
+			resolver({
+				outcome: "selected",
+				optionId
+			});
+			this.emit("permissionResolved", {
+				requestId,
+				optionId
+			});
+			return true;
+		}
+		return false;
+	}
+	rejectPermission(requestId, reason) {
+		const resolver = this[`_permissionResolver_${requestId}`];
+		if (resolver) {
+			this.pendingPermissions.delete(requestId);
+			delete this[`_permissionResolver_${requestId}`];
+			resolver({ outcome: "cancelled" });
+			this.emit("permissionRejected", {
+				requestId,
+				reason
+			});
+			return true;
+		}
+		return false;
+	}
+	getPendingPermissions() {
+		const result = /* @__PURE__ */ new Map();
+		for (const [requestId, pending] of this.pendingPermissions) result.set(requestId, {
+			params: {
+				sessionId: pending.params.sessionId,
+				toolCall: pending.params.toolCall,
+				options: pending.params.options
+			},
+			createdAt: pending.createdAt
+		});
+		return result;
+	}
+	hasPendingPermissions() {
+		return this.pendingPermissions.size > 0;
+	}
+	answerQuestion(_toolCallId, _answers) {
+		return false;
+	}
+	/**
+	* 工具回调操作
+	* 用于对正在执行的工具进行 approve / skip / cancel 操作
+	* @param sessionId 会话 ID
+	* @param toolCallId 工具调用 ID
+	* @param toolName 工具名称
+	* @param action 操作类型 ('approve' | 'skip' | 'cancel')
+	* @returns 工具回调响应
+	*/
+	async toolCallback(sessionId, toolCallId, toolName, action) {
+		this.log("toolCallback called for session:", sessionId, "action:", action);
+		const request = {
+			sessionId,
+			toolCallId,
+			toolName,
+			action
+		};
+		return await this.acpClient.toolCallback(request);
+	}
+	cancelQuestion(_toolCallId, _reason) {
+		return false;
+	}
+	getPendingQuestions() {
+		return /* @__PURE__ */ new Map();
+	}
+	hasPendingQuestions() {
+		return false;
+	}
+	async reportTelemetry(eventName, payload) {
+		try {
+			await this.acpClient.sendRequest(this.agentId, "reportTelemetry", {
+				eventName,
+				payload
+			});
+		} catch (error) {
+			console.warn("[LocalAgentConnection] reportTelemetry failed:", error);
+		}
+	}
+	async extMethod(_method, _params) {
+		throw new Error("extMethod not implemented for Local connection");
+	}
+	async extNotification(_method, _params) {
+		throw new Error("extNotification not implemented for Local connection");
+	}
+	async readFile(_path) {
+		throw new Error("readFile not implemented for Local connection");
+	}
+	async listDir(_path) {
+		throw new Error("listDir not implemented for Local connection");
+	}
+	async fileExists(_path) {
+		throw new Error("fileExists not implemented for Local connection");
+	}
+	async fileStat(_path) {
+		throw new Error("fileStat not implemented for Local connection");
+	}
+	log(...args) {
+		console.log("[LocalAgentConnection]", ...args);
+	}
+};
+
+//#endregion
+//#region ../agent-provider/src/common/providers/local-agent-provider/local-filesystem.ts
+/**
+* Filesystem JSON-RPC 方法名称
+*/
+const FILESYSTEM_METHODS = {
+	READ: "fs/read",
+	WRITE: "fs/write",
+	LIST: "fs/list",
+	EXISTS: "fs/exists",
+	MAKE_DIR: "fs/makeDir",
+	REMOVE: "fs/remove",
+	RENAME: "fs/rename",
+	GET_INFO: "fs/getInfo",
+	WATCH_DIR: "fs/watchDir",
+	UNWATCH: "fs/unwatch"
+};
+/**
+* Watch 句柄 ID 生成计数器
+*/
+let watchIdCounter = 0;
+/**
+* LocalFilesystem
+*
+* 实现 FilesResource 接口，将 filesystem 操作通过 JSON-RPC 发送到 ExtensionHost
+*/
+var LocalFilesystem = class {
+	constructor(client, sessionId, options) {
+		this.watchCallbacks = /* @__PURE__ */ new Map();
+		this.client = client;
+		this.sessionId = sessionId;
+		this.debug = options?.debug ?? false;
+		this.setupEventListener();
+	}
+	/**
+	* 设置 filesystem 事件监听（用于 watchDir）
+	*/
+	setupEventListener() {
+		const dispose = this.client.onExtNotification((method, params) => {
+			if (method !== "fs-event") return;
+			const data = params;
+			if (data?.watchId) {
+				const callback = this.watchCallbacks.get(data.watchId);
+				if (callback) callback({
+					type: data.eventType,
+					name: data.name,
+					path: data.path
+				});
+			}
+		});
+		this.eventCleanup = () => dispose?.();
+	}
+	/**
+	* 发送 filesystem 请求到 ExtensionHost
+	*/
+	async sendRequest(method, params) {
+		console.log(`[LocalFilesystem] sendRequest: ${method}`, params);
+		try {
+			const result = await this.client.sendRequest(this.sessionId, method, params);
+			if (result && typeof result === "object") {
+				if ("error" in result && result.error) throw new Error(result.error);
+				if ("data" in result) return result.data;
+			}
+			return result;
+		} catch (error) {
+			console.error("[LocalFilesystem] error:", error);
+			throw error;
+		}
+	}
+	async read(path, opts) {
+		const format = opts?.format ?? "text";
+		if (format === "text") return this.sendRequest(FILESYSTEM_METHODS.READ, {
+			path,
+			opts,
+			format: "text"
+		});
+		const base64Data = await this.sendRequest(FILESYSTEM_METHODS.READ, {
+			path,
+			opts,
+			format: "bytes"
+		});
+		const binaryString = atob(base64Data);
+		const bytes = new Uint8Array(binaryString.length);
+		for (let i = 0; i < binaryString.length; i++) bytes[i] = binaryString.charCodeAt(i);
+		if (format === "bytes") return bytes;
+		else if (format === "blob") return new Blob([bytes]);
+		else return new ReadableStream({ start(controller) {
+			controller.enqueue(bytes);
+			controller.close();
+		} });
+	}
+	async write(pathOrFiles, dataOrOpts, opts) {
+		console.log("[LocalFilesystem] write() called:", {
+			sessionId: this.sessionId,
+			isArray: Array.isArray(pathOrFiles),
+			pathOrFiles: Array.isArray(pathOrFiles) ? `${pathOrFiles.length} files` : pathOrFiles
+		});
+		if (Array.isArray(pathOrFiles)) {
+			const files = await Promise.all(pathOrFiles.map(async (entry) => ({
+				path: entry.path,
+				data: await this.convertDataToString(entry.data)
+			})));
+			return this.sendRequest(FILESYSTEM_METHODS.WRITE, {
+				path: "",
+				files,
+				opts: dataOrOpts
+			});
+		} else {
+			const dataStr = await this.convertDataToString(dataOrOpts);
+			return this.sendRequest(FILESYSTEM_METHODS.WRITE, {
+				path: pathOrFiles,
+				data: dataStr,
+				opts
+			});
+		}
+	}
+	/**
+	* 将数据转换为字符串（用于传输）
+	*/
+	async convertDataToString(data) {
+		if (typeof data === "string") return data;
+		else if (data instanceof ArrayBuffer) return this.arrayBufferToBase64(data);
+		else if (data instanceof Blob) return this.blobToBase64(data);
+		else if (data && typeof data.getReader === "function") {
+			const reader = data.getReader();
+			const chunks = [];
+			let done = false;
+			while (!done) {
+				const result = await reader.read();
+				done = result.done;
+				if (result.value) chunks.push(result.value);
+			}
+			const totalLength = chunks.reduce((sum, chunk) => sum + chunk.length, 0);
+			const combined = new Uint8Array(totalLength);
+			let offset = 0;
+			for (const chunk of chunks) {
+				combined.set(chunk, offset);
+				offset += chunk.length;
+			}
+			return this.arrayBufferToBase64(combined.buffer);
+		}
+		return String(data);
+	}
+	/**
+	* 列出目录内容
+	*/
+	async list(path, opts) {
+		return this.sendRequest(FILESYSTEM_METHODS.LIST, {
+			path,
+			opts,
+			depth: opts?.depth
+		});
+	}
+	/**
+	* 检查路径是否存在
+	*/
+	async exists(path, opts) {
+		return this.sendRequest(FILESYSTEM_METHODS.EXISTS, {
+			path,
+			opts
+		});
+	}
+	/**
+	* 创建目录
+	*/
+	async makeDir(path, opts) {
+		return this.sendRequest(FILESYSTEM_METHODS.MAKE_DIR, {
+			path,
+			opts
+		});
+	}
+	/**
+	* 删除文件或目录
+	*/
+	async remove(path, opts) {
+		await this.sendRequest(FILESYSTEM_METHODS.REMOVE, {
+			path,
+			opts
+		});
+	}
+	/**
+	* 重命名/移动文件或目录
+	*/
+	async rename(oldPath, newPath, opts) {
+		return this.sendRequest(FILESYSTEM_METHODS.RENAME, {
+			path: oldPath,
+			newPath,
+			opts
+		});
+	}
+	/**
+	* 获取文件或目录信息
+	*/
+	async getInfo(path, opts) {
+		return this.sendRequest(FILESYSTEM_METHODS.GET_INFO, {
+			path,
+			opts
+		});
+	}
+	/**
+	* 监听目录变化
+	*/
+	async watchDir(path, onEvent, opts) {
+		const watchId = `watch-${++watchIdCounter}-${Date.now()}`;
+		this.watchCallbacks.set(watchId, onEvent);
+		await this.sendRequest(FILESYSTEM_METHODS.WATCH_DIR, {
+			path,
+			recursive: opts?.recursive,
+			opts: {
+				...opts,
+				user: watchId
+			}
+		});
+		return { stop: async () => {
+			this.watchCallbacks.delete(watchId);
+			try {
+				await this.sendRequest(FILESYSTEM_METHODS.UNWATCH, {
+					path,
+					opts: { user: watchId }
+				});
+			} catch (error) {
+				this.log(`Failed to unwatch: ${path}`, error);
+			}
+			if (opts?.onExit) opts.onExit();
+		} };
+	}
+	/**
+	* ArrayBuffer 转 Base64
+	*/
+	arrayBufferToBase64(buffer) {
+		const bytes = new Uint8Array(buffer);
+		let binary = "";
+		for (let i = 0; i < bytes.byteLength; i++) binary += String.fromCharCode(bytes[i]);
+		return btoa(binary);
+	}
+	/**
+	* Blob 转 Base64
+	*/
+	async blobToBase64(blob) {
+		return new Promise((resolve, reject) => {
+			const reader = new FileReader();
+			reader.onloadend = () => {
+				const result = reader.result;
+				resolve(result.split(",")[1] || result);
+			};
+			reader.onerror = reject;
+			reader.readAsDataURL(blob);
+		});
+	}
+	/**
+	* 日志输出
+	*/
+	log(...args) {
+		if (this.debug) console.log("[LocalFilesystem]", ...args);
+	}
+	/**
+	* 销毁实例，清理资源
+	*/
+	destroy() {
+		this.watchCallbacks.clear();
+		if (this.eventCleanup) {
+			this.eventCleanup();
+			this.eventCleanup = void 0;
+		}
+	}
+};
+
+//#endregion
+//#region ../agent-provider/src/common/providers/local-agent-provider/local-provider.ts
+/**
+* LocalAgentProvider
+*
+* 实现统一两层模型的 Local 端适配：
+* - 第一层 (Window/Workspace): 由 IDE/用户管理，Provider 只负责调用 openWorkspace
+* - 第二层 (Session): 由 Provider 管理
+*
+* 核心方法语义：
+* - create(): 返回 cwd 作为 "agentId"（需先调用 prepareCreate 预设）
+* - get(id): 支持 cwd 和 sessionId 两种输入，返回 Session 状态
+* - list(): 返回所有 Sessions
+* - connect(id): 智能判断 id 类型，建立连接
+* - delete(id): 删除 Session
+*
+* 同时实现 FilesystemProvider 接口，提供文件系统访问能力
+*/
+var LocalAgentProvider = class LocalAgentProvider {
+	static {
+		this.ARCHIVED_SESSIONS_KEY = "genie-archived-session-ids";
+	}
+	/**
+	* 从 localStorage 读取归档 session ID 集合
+	*/
+	getArchivedSessionIds() {
+		try {
+			const raw = localStorage.getItem(LocalAgentProvider.ARCHIVED_SESSIONS_KEY);
+			return raw ? new Set(JSON.parse(raw)) : /* @__PURE__ */ new Set();
+		} catch {
+			return /* @__PURE__ */ new Set();
+		}
+	}
+	/**
+	* 将归档 session ID 集合保存到 localStorage
+	*/
+	saveArchivedSessionIds(ids) {
+		try {
+			localStorage.setItem(LocalAgentProvider.ARCHIVED_SESSIONS_KEY, JSON.stringify([...ids]));
+		} catch {}
+	}
+	constructor(options) {
+		this.connections = /* @__PURE__ */ new Map();
+		this.sessionCwdMap = /* @__PURE__ */ new Map();
+		this.filesystemCache = /* @__PURE__ */ new Map();
+		this.samplingRequestCallbacks = /* @__PURE__ */ new Map();
+		this.rootsRequestCallbacks = /* @__PURE__ */ new Map();
+		this.mcpEventListenersSetup = false;
+		if (!options.channel) throw new Error("Channel is required for LocalAgentProvider");
+		this.options = options;
+		this.channel = options.channel;
+		this.sharedAcpClient = new AcpJsonRpcClient(this.channel, {
+			timeoutMs: options.acpConfig?.timeoutMs ?? 3e4,
+			debug: options.debug ?? false
+		});
+		this.sharedAcpClient.onExtNotification((method, params) => {
+			if (method === "_codebuddy.ai/automation_snapshot") {
+				const snapshot = params.snapshot;
+				if (snapshot) this.channel.emit("automationSnapshotUpdate", snapshot);
+			}
+			if (method === "_codebuddy.ai/plugins_changed") this.channel.emit("pluginsChanged", params);
+			if (method === "_codebuddy.ai/models_changed") this.channel.emit("modelsChanged", params);
+			if (method === "_codebuddy.ai/product_config_changed") this.channel.emit("productConfigChanged", params);
+			if (method === "_codebuddy.ai/identity_changed") {
+				console.log("[LocalProvider] Received identity_changed extNotification, emitting identityChanged event:", JSON.stringify(params));
+				this.channel.emit("identityChanged", params);
+			}
+			if (method === "_codebuddy.ai/mcp_servers_changed") this.channel.emit("mcpServersChanged", params);
+		});
+	}
+	/**
+	* 实现 AgentProvider.filesystem 属性
+	* 返回 this，因为 LocalAgentProvider 本身实现了 FilesystemProvider 接口
+	*/
+	get filesystem() {
+		return this;
+	}
+	/**
+	* 创建 "Agent"
+	*
+	* 对于 Local，返回 cwd 作为 agentId
+	* 后续 connect(cwd) 和 connection.createSession() 会使用它
+	*
+	* @param params - 会话创建参数，包含 cwd
+	* @returns cwd 作为 "agentId"
+	*/
+	async create(params) {
+		const cwd = params?.cwd;
+		if (cwd === void 0) throw new Error("cwd is required for LocalAgentProvider.create()");
+		this.log(`create() returning cwd as agentId: ${cwd}`);
+		return cwd;
+	}
+	/**
+	* 获取 Session 状态
+	*
+	* SessionManager.loadSession() 会用 sessionId 调用此方法
+	* 需要返回包含 cwd 的状态，以便后续 connect()
+	*
+	* @param id - 可能是 sessionId 或 cwd
+	* @returns Session 状态
+	*/
+	async get(id) {
+		this.log(`get() called with: ${id}`);
+		if (id.startsWith("/")) return {
+			id,
+			type: "local",
+			status: "disconnected",
+			cwd: id
+		};
+		const cachedCwd = this.sessionCwdMap.get(id);
+		if (cachedCwd) return {
+			id,
+			type: "local",
+			status: "connected",
+			cwd: cachedCwd
+		};
+		try {
+			const session = (await this.channel.callMethod("__backend__", {
+				type: "backend",
+				requestId: `req-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+				params: {
+					type: "backend:get-session-request",
+					params: { sessionId: id }
+				}
+			}, 5e3)).data?.session;
+			if (!session) {
+				this.log(`Session not found: ${id}`);
+				return;
+			}
+			if (session.cwd) this.sessionCwdMap.set(id, session.cwd);
+			return {
+				id: session.sessionId,
+				type: "local",
+				status: session.status === "active" ? "connected" : "disconnected",
+				cwd: session.cwd,
+				name: session.name,
+				createdAt: session.createdAt ? new Date(session.createdAt) : void 0
+			};
+		} catch (error) {
+			this.log(`Failed to get session ${id}:`, error);
+			return;
+		}
+	}
+	/**
+	* 列出所有 Sessions
+	*
+	* @param options - 可选的查询参数（过滤、排序、userId）
+	* @returns Session 状态列表和分页信息
+	*/
+	async list(options) {
+		this.log("list() called with options:", options);
+		if (!options?.userId) {
+			this.log("No userId provided, returning empty list");
+			return {
+				agents: [],
+				pagination: {
+					page: 1,
+					size: 0,
+					total: 0,
+					totalPages: 0,
+					hasNext: false,
+					hasPrev: false
+				}
+			};
+		}
+		try {
+			const sessions = (await this.channel.callMethod("__backend__", {
+				type: "backend",
+				requestId: `req-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+				params: {
+					type: "backend:list-sessions-request",
+					params: { userId: options.userId }
+				}
+			}, 5e3)).data?.sessions ?? [];
+			this.log(`Found ${sessions.length} sessions for userId: ${options.userId}`);
+			for (const session of sessions) if (session.sessionId && session.cwd) this.sessionCwdMap.set(session.sessionId, session.cwd);
+			let result = sessions.map((session) => ({
+				id: session.sessionId,
+				type: "local",
+				status: session.status,
+				cwd: session.cwd,
+				name: session.name,
+				createdAt: session.createdAt ? new Date(session.createdAt) : void 0,
+				isPlayground: session.isPlayground,
+				isUserDefinedTitle: session.isUserDefinedTitle
+			}));
+			const archivedIds = this.getArchivedSessionIds();
+			const isQueryingArchived = options?.filters?.some((f) => f.field === "status" && f.value.split(",").map((v) => v.trim()).includes("archived"));
+			if (isQueryingArchived) result = result.filter((s) => archivedIds.has(s.id)).map((s) => ({
+				...s,
+				status: "archived"
+			}));
+			else result = result.filter((s) => !archivedIds.has(s.id));
+			if (options) result = this.applyFilters(result, options, isQueryingArchived);
+			return {
+				agents: result,
+				pagination: {
+					page: 1,
+					size: result.length,
+					total: result.length,
+					totalPages: 1,
+					hasNext: false,
+					hasPrev: false
+				}
+			};
+		} catch (error) {
+			this.log("Failed to list sessions:", error);
+			return {
+				agents: [],
+				pagination: {
+					page: 1,
+					size: 0,
+					total: 0,
+					totalPages: 0,
+					hasNext: false,
+					hasPrev: false
+				}
+			};
+		}
+	}
+	/**
+	* 应用本地过滤和排序
+	*/
+	applyFilters(sessions, options, skipStatusArchived = false) {
+		let filtered = [...sessions];
+		if (options.title) {
+			const keyword = options.title.toLowerCase();
+			filtered = filtered.filter((s) => s.name?.toLowerCase().includes(keyword));
+		}
+		if (options.filters?.length) for (const filter of options.filters) {
+			if (skipStatusArchived && filter.field === "status" && filter.value.includes("archived")) continue;
+			const values = filter.value.split(",").map((v) => v.trim());
+			filtered = filtered.filter((s) => {
+				const fieldValue = s[filter.field];
+				if (filter.field === "sessionStatus") return values.includes(s.status.toLowerCase()) || values.includes(String(fieldValue));
+				return values.includes(String(fieldValue));
+			});
+		}
+		if (options.dayRange !== void 0) {
+			const cutoff = /* @__PURE__ */ new Date();
+			cutoff.setDate(cutoff.getDate() - (options.dayRange - 1));
+			cutoff.setHours(0, 0, 0, 0);
+			filtered = filtered.filter((s) => s.createdAt && s.createdAt >= cutoff);
+		}
+		if (options.sort) {
+			const { orderBy, order = "asc" } = options.sort;
+			filtered.sort((a, b) => {
+				const aVal = a[orderBy];
+				const bVal = b[orderBy];
+				if (aVal === void 0) return 1;
+				if (bVal === void 0) return -1;
+				let cmp = 0;
+				if (aVal instanceof Date && bVal instanceof Date) cmp = aVal.getTime() - bVal.getTime();
+				else if (typeof aVal === "string" && typeof bVal === "string") cmp = aVal.localeCompare(bVal);
+				else cmp = aVal < bVal ? -1 : aVal > bVal ? 1 : 0;
+				return order === "desc" ? -cmp : cmp;
+			});
+		}
+		return filtered;
+	}
+	/**
+	* 连接到工作区
+	*
+	* @param id - 可能是 cwd（createSession 流程）或 sessionId（loadSession 流程）
+	* @returns LocalAgentConnection 实例
+	*/
+	async connect(id) {
+		this.log(`connect() called with: ${id}`);
+		let cwd;
+		if (id.includes("/")) cwd = id;
+		else {
+			cwd = this.sessionCwdMap.get(id) || "";
+			if (cwd === void 0) cwd = (await this.get(id))?.cwd || "";
+			if (cwd === void 0) throw new Error(`Cannot find cwd for session: ${id}`);
+		}
+		this.log(`Resolved cwd: ${cwd}`);
+		const existing = this.connections.get(cwd);
+		if (existing?.isInitialized) {
+			this.log(`Reusing existing connection for: ${cwd}`);
+			return existing;
+		}
+		this.log(`Opening workspace: ${cwd}`);
+		const clientCapabilities = {
+			...this.options.clientCapabilities,
+			_meta: {
+				...this.options.clientCapabilities?._meta,
+				"codebuddy.ai": {
+					...this.options.clientCapabilities?._meta?.["codebuddy.ai"],
+					cwd
+				}
+			}
+		};
+		const config = {
+			channel: this.channel,
+			debug: this.options.debug,
+			acpConfig: this.options.acpConfig,
+			permissionTimeout: this.options.permissionTimeout,
+			permissionAutoRejectOnTimeout: this.options.permissionAutoRejectOnTimeout,
+			clientCapabilities
+		};
+		const connection = new LocalAgentConnection(cwd, config);
+		await connection.connect(clientCapabilities);
+		this.connections.set(cwd, connection);
+		connection.once("disconnected", () => {
+			this.connections.delete(cwd);
+			this.log(`Connection removed from cache: ${cwd}`);
+		});
+		this.log(`Connected to workspace: ${cwd}`);
+		return connection;
+	}
+	/**
+	* 删除 Session
+	*
+	* @param sessionId - 会话 ID
+	* @returns 是否成功删除
+	*/
+	async delete(sessionId) {
+		this.log(`delete() called with: ${sessionId}`);
+		this.sessionCwdMap.delete(sessionId);
+		try {
+			return (await this.channel.callMethod("__backend__", {
+				type: "backend",
+				requestId: `req-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+				params: {
+					type: "backend:delete-session-request",
+					params: { sessionId }
+				}
+			}, 5e3)).data?.success ?? false;
+		} catch (error) {
+			this.log(`Failed to delete session ${sessionId}:`, error);
+			return false;
+		}
+	}
+	/**
+	* 归档 Session
+	*
+	* 纯前端实现：将 sessionId 加入 localStorage 的归档集合，
+	* 不删除后端数据，以便后续可恢复。
+	*
+	* @param sessionId - 会话 ID
+	* @returns 包含归档的 session ID 的对象
+	*/
+	async archive(sessionId) {
+		this.log(`archive() called with: ${sessionId}`);
+		const archivedIds = this.getArchivedSessionIds();
+		archivedIds.add(sessionId);
+		this.saveArchivedSessionIds(archivedIds);
+		return { id: sessionId };
+	}
+	/**
+	* 更新 Session 状态
+	*
+	* 纯前端实现：当 status 不为 'archived' 时，将 sessionId 从归档集合中移除（恢复归档）。
+	*
+	* @param sessionId - 会话 ID
+	* @param status - 新状态
+	* @returns 包含 session ID 的对象
+	*/
+	async updateStatus(sessionId, status) {
+		this.log(`updateStatus() called with: ${sessionId}, status: ${status}`);
+		if (status !== "archived") {
+			const archivedIds = this.getArchivedSessionIds();
+			archivedIds.delete(sessionId);
+			this.saveArchivedSessionIds(archivedIds);
+		} else {
+			const archivedIds = this.getArchivedSessionIds();
+			archivedIds.add(sessionId);
+			this.saveArchivedSessionIds(archivedIds);
+		}
+		return { id: sessionId };
+	}
+	/**
+	* 重命名 Session
+	*
+	* @param sessionId - 会话 ID
+	* @param title - 新标题
+	* @returns 包含重命名的 session ID 的对象
+	*/
+	async rename(sessionId, title) {
+		this.log(`rename() called with: ${sessionId}, title: ${title}`);
+		try {
+			const response = await this.channel.callMethod("__backend__", {
+				type: "backend",
+				requestId: `req-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+				params: {
+					type: "backend:rename-session-request",
+					params: {
+						sessionId,
+						title
+					}
+				}
+			}, 5e3);
+			if (!response.data?.success) throw new Error(response.data?.error || "Failed to rename session");
+			return { id: sessionId };
+		} catch (error) {
+			this.log(`Failed to rename session ${sessionId}:`, error);
+			throw error;
+		}
+	}
+	/**
+	* 移动 Session
+	* 将 Playground 会话转换为普通会话（从 Playground 移动到 Workspace）
+	*
+	* @param sessionId - 会话 ID
+	* @returns 包含移动的 session ID 的对象
+	*/
+	async move(sessionId) {
+		this.log(`move() called with: ${sessionId}`);
+		try {
+			const response = await this.channel.callMethod("__backend__", {
+				type: "backend",
+				requestId: `req-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+				params: {
+					type: "backend:move-session-request",
+					params: { sessionId }
+				}
+			}, 5e3);
+			if (!response.data?.success) throw new Error(response.data?.error || "Failed to move session");
+			this.log(`move() succeeded for: ${sessionId}`);
+			return { id: sessionId };
+		} catch (error) {
+			this.log(`Failed to move session ${sessionId}:`, error);
+			throw error;
+		}
+	}
+	/**
+	* 注册 sessionId → cwd 映射
+	*
+	* 在 connection.createSession() 成功后调用，记录新创建的 session
+	*
+	* @param sessionId - 会话 ID
+	* @param cwd - 工作区路径
+	*/
+	registerSession(sessionId, cwd) {
+		this.sessionCwdMap.set(sessionId, cwd);
+		this.log(`Registered session: ${sessionId} → ${cwd}`);
+	}
+	/**
+	* 获取可用模型列表
+	*
+	* 通过 ACP JSON-RPC 调用 getModels 方法
+	* cwd 为空时会路由到 Default Window
+	*
+	* @param cwd - 工作目录，可选。为空时使用 Default Window
+	* @param mode - 模式过滤，可选
+	* @returns 模型列表
+	*/
+	async getModels(cwd, mode) {
+		this.log(`getModels() called with cwd: ${cwd || "(empty)"}, mode: ${mode || "(default)"}`);
+		try {
+			const response = await this.sharedAcpClient.sendBroadcastRequest("getModels", {
+				cwd: cwd || "",
+				mode
+			});
+			if (response?.models) {
+				this.log(`getModels() returned ${response.models.length} models`);
+				return response.models.map((model) => ({
+					...model,
+					...model._meta?.["codebuddy.ai"] || {}
+				}));
+			}
+			this.log("getModels() - no models in response");
+			return [];
+		} catch (error) {
+			this.log("getModels() failed:", error);
+			return [];
+		}
+	}
+	/**
+	* 获取可用模式列表
+	*
+	* 通过 ACP JSON-RPC 调用 getModes 方法
+	* cwd 为空时会路由到 Default Window
+	*
+	* @param cwd - 工作目录，可选。为空时使用 Default Window
+	* @returns 模式列表
+	*/
+	async getModes(cwd) {
+		this.log(`getModes() called with cwd: ${cwd || "(empty)"}`);
+		try {
+			const response = await this.sharedAcpClient.sendBroadcastRequest("getModes", { cwd: cwd || "" });
+			if (response?.modes) {
+				this.log(`getModes() returned ${response.modes.length} modes`);
+				return response.modes;
+			}
+			this.log("getModes() - no modes in response");
+			return [];
+		} catch (error) {
+			this.log("getModes() failed:", error);
+			return [];
+		}
+	}
+	/**
+	* 获取产品配置子集
+	*
+	* 通过 ACP JSON-RPC 调用 getProductConfiguration 方法
+	* 返回 deploymentType、creditPurchaseActions、links 等配置
+	*
+	* @returns 产品配置子集
+	*/
+	async getProductConfiguration() {
+		this.log("getProductConfiguration() called");
+		try {
+			const response = await this.sharedAcpClient.sendBroadcastRequest("getProductConfiguration", {});
+			this.log("getProductConfiguration() returned:", response);
+			return response ?? {};
+		} catch (error) {
+			this.log("getProductConfiguration() failed:", error);
+			return {};
+		}
+	}
+	/**
+	* 获取 Identity 名称
+	* 读取 ~/.workbuddy/IDENTITY.md 中的 Name 字段，用于兼容 localStorage 尚未缓存的历史用户
+	*/
+	async getIdentityName() {
+		try {
+			return await this.sharedAcpClient.sendBroadcastRequest("getIdentityName", {}) ?? {};
+		} catch (error) {
+			this.log("getIdentityName() failed:", error);
+			return {};
+		}
+	}
+	/**
+	* 获取用户信息
+	*
+	* 通过 ACP JSON-RPC 调用 getUserInfo 方法
+	* 返回当前登录用户的 enterpriseId 等信息
+	*
+	* @returns 用户信息
+	*/
+	async getUserInfo() {
+		this.log("getUserInfo() called");
+		try {
+			const response = await this.sharedAcpClient.sendBroadcastRequest("getUserInfo", {});
+			this.log("getUserInfo() returned:", response);
+			return response ?? {};
+		} catch (error) {
+			this.log("getUserInfo() failed:", error);
+			return {};
+		}
+	}
+	/**
+	* 打开工作区窗口
+	* 这是 LocalAgentProvider 特有的能力，通过 shared ACP client 发送请求，
+	* 使用 __workspace__ session ID，由 Main Process 直接处理，不转发到 ExtensionHost
+	*
+	* @param params 打开工作区请求参数
+	* @returns 打开工作区响应
+	*/
+	async openWorkspace(params) {
+		this.log("Opening workspace:", params.cwd);
+		return await this.sharedAcpClient.openWorkspace(params);
+	}
+	/**
+	* 选择文件
+	* 通过 BackendService 的 __backend__ session 处理
+	*
+	* @param params 文件选择参数
+	* @returns 选择结果
+	*/
+	async pickFile(params) {
+		this.log("Picking file:", params);
+		try {
+			const response = await this.channel.callMethod("__backend__", {
+				type: "backend",
+				requestId: `req-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+				params: {
+					type: "backend:pick-file",
+					params
+				}
+			}, 3e4);
+			this.log("pickFile() response:", response.data);
+			const data = response.data;
+			return {
+				files: data.filePaths || [],
+				canceled: data.canceled ?? false,
+				error: data.error
+			};
+		} catch (error) {
+			this.log("pickFile() failed:", error);
+			return {
+				files: [],
+				canceled: true,
+				error: error instanceof Error ? error.message : "Unknown error"
+			};
+		}
+	}
+	/**
+	* 选择文件夹
+	* 通过 BackendService 的 __backend__ session 处理
+	*
+	* @param params 文件夹选择参数
+	* @returns 选择结果
+	*/
+	async pickFolder(params) {
+		this.log("Picking folder:", params);
+		try {
+			const response = await this.channel.callMethod("__backend__", {
+				type: "backend",
+				requestId: `req-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+				params: {
+					type: "backend:pick-folder",
+					params
+				}
+			}, 3e4);
+			this.log("pickFolder() response:", response.data);
+			const data = response.data;
+			return {
+				folderPaths: data?.paths || [],
+				canceled: data?.cancelled ?? true,
+				error: data?.error
+			};
+		} catch (error) {
+			this.log("pickFolder() failed:", error);
+			return {
+				folderPaths: [],
+				canceled: true,
+				error: error instanceof Error ? error.message : "Unknown error"
+			};
+		}
+	}
+	/**
+	* 搜索文件
+	* 通过 shared ACP client 发送广播请求到 Extension Host
+	* Extension Host 中的 FileSearchService 会处理这个请求
+	*
+	* @param params 搜索参数
+	* @returns 搜索结果
+	*/
+	async searchFile(params) {
+		this.log("Searching files:", params.options);
+		try {
+			const response = await this.sharedAcpClient.sendBroadcastRequest("getWorkspaceFiles", {
+				cwd: params.cwd,
+				search: params.options.search,
+				resultNum: params.options.resultNum
+			});
+			this.log("searchFile() response:", response);
+			return {
+				results: response.results.map((r) => ({
+					...r,
+					type: r.type
+				})),
+				error: void 0
+			};
+		} catch (error) {
+			this.log("searchFile() failed:", error);
+			return {
+				results: [],
+				error: error instanceof Error ? error.message : "Unknown error"
+			};
+		}
+	}
+	/**
+	* 获取 Subagent 列表
+	* 通过 shared ACP client 发送广播请求到 Extension Host
+	* Extension Host 中的 SubagentsService 会处理这个请求
+	*
+	* @param params 查询参数
+	* @returns Subagent 列表
+	*/
+	async getSubagentList(params) {
+		this.log("Getting subagent list:", params.options);
+		try {
+			const response = await this.sharedAcpClient.sendBroadcastRequest("getSubagentList", {
+				cwd: params.cwd,
+				search: params.options.search,
+				resultNum: params.options.resultNum,
+				agentMode: params.options.agentMode || "all",
+				onlyEnabled: params.options.onlyEnabled
+			});
+			this.log("getSubagentList() response:", response);
+			return {
+				results: response.subagents,
+				error: void 0
+			};
+		} catch (error) {
+			this.log("getSubagentList() failed:", error);
+			return {
+				results: [],
+				error: error instanceof Error ? error.message : "Unknown error"
+			};
+		}
+	}
+	/**
+	* 获取 Skill 列表
+	*
+	* @param params 查询参数
+	* @returns Skill 列表
+	*/
+	async getSkillList(params) {
+		this.log("Getting skill list:", params);
+		const useGlobal = params?.global ?? true;
+		try {
+			if (!useGlobal || params?.cwd) {
+				const response = await this.sharedAcpClient.sendBroadcastRequest("getSkillList", {
+					cwd: params?.cwd ?? "",
+					excludePluginSkills: params?.excludePluginSkills ?? false
+				});
+				this.log("getSkillList() broadcast response:", response);
+				return {
+					results: response.skills,
+					error: void 0
+				};
+			}
+			const backendResponse = await this.channel.callMethod("__backend__", {
+				type: "backend",
+				requestId: `req-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+				params: {
+					type: "backend:get-skill-list",
+					params: { skillScanDirs: params?.skillScanDirs }
+				}
+			}, 3e4);
+			this.log("getSkillList() backend response:", backendResponse.data);
+			const data = backendResponse.data;
+			return {
+				results: data?.skills ?? [],
+				error: data?.error
+			};
+		} catch (error) {
+			this.log("getSkillList() failed:", error);
+			return {
+				results: [],
+				error: error instanceof Error ? error.message : "Unknown error"
+			};
+		}
+	}
+	/**
+	* 导入 Skill 文件夹
+	*
+	* @param params 导入参数
+	* @returns 导入结果
+	*/
+	async importSkill(params) {
+		this.log("Importing skill folder:", params);
+		try {
+			const backendResponse = await this.channel.callMethod("__backend__", {
+				type: "backend",
+				requestId: `req-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+				params: {
+					type: "backend:import-skill",
+					params: {
+						cwd: params.cwd,
+						source: params.source,
+						folderPath: params.folderPath
+					}
+				}
+			}, 3e4);
+			this.log("importSkill() backend response:", backendResponse.data);
+			const data = backendResponse.data;
+			return {
+				success: data?.success ?? false,
+				error: data?.error,
+				skillName: data?.skillName
+			};
+		} catch (error) {
+			this.log("importSkill() failed:", error);
+			return {
+				success: false,
+				error: error instanceof Error ? error.message : "Unknown error"
+			};
+		}
+	}
+	/**
+	* 切换 Skill 启用/禁用状态
+	*
+	* @param params 切换参数
+	* @returns 切换结果
+	*/
+	async toggleSkill(params) {
+		this.log("Toggling skill:", params.filePath, "disable:", params.disable);
+		try {
+			const response = await this.sharedAcpClient.sendBroadcastRequest("toggleSkill", {
+				filePath: params.filePath,
+				disable: params.disable
+			});
+			this.log("toggleSkill() response:", response);
+			return {
+				success: response?.success ?? false,
+				error: response?.error
+			};
+		} catch (error) {
+			this.log("toggleSkill() failed:", error);
+			return {
+				success: false,
+				error: error instanceof Error ? error.message : "Unknown error"
+			};
+		}
+	}
+	/**
+	* 删除 Skill
+	*
+	* @param params 删除参数
+	* @returns 删除结果
+	*/
+	async deleteSkill(params) {
+		this.log("Deleting skill:", params.name, "at", params.filePath);
+		try {
+			const response = await this.sharedAcpClient.sendBroadcastRequest("deleteSkill", {
+				filePath: params.filePath,
+				name: params.name
+			});
+			this.log("deleteSkill() response:", response);
+			return {
+				success: response?.success ?? false,
+				error: response?.error
+			};
+		} catch (error) {
+			this.log("deleteSkill() failed:", error);
+			return {
+				success: false,
+				error: error instanceof Error ? error.message : "Unknown error"
+			};
+		}
+	}
+	/**
+	* 获取 Skill 内容
+	* 通过 shared ACP client 发送广播请求到 Extension Host
+	*
+	* @param params 包含 filePath 的参数
+	* @returns Skill 文件内容
+	*/
+	async getSkillContent(params) {
+		this.log("Getting skill content:", params.filePath);
+		try {
+			const response = await this.sharedAcpClient.sendBroadcastRequest("getSkillContent", { filePath: params.filePath });
+			this.log("getSkillContent() response:", response);
+			return {
+				content: response?.content ?? "",
+				error: response?.error
+			};
+		} catch (error) {
+			this.log("getSkillContent() failed:", error);
+			return {
+				content: "",
+				error: error instanceof Error ? error.message : "Unknown error"
+			};
+		}
+	}
+	/**
+	* 获取推荐 Skill 列表（从市场）
+	* 通过 shared ACP client 发送广播请求到 Extension Host
+	*
+	* @returns 推荐 Skill 列表
+	*/
+	async getMarketplaceSkills() {
+		this.log("Getting marketplace skills");
+		try {
+			const response = await this.sharedAcpClient.sendBroadcastRequest("getMarketplaceSkills", {});
+			this.log("getMarketplaceSkills() response:", response);
+			return { results: response?.skills ?? [] };
+		} catch (error) {
+			this.log("getMarketplaceSkills() failed:", error);
+			return {
+				results: [],
+				error: error instanceof Error ? error.message : "Unknown error"
+			};
+		}
+	}
+	/**
+	* 获取市场 Skill 内容
+	* 通过 shared ACP client 发送广播请求到 Extension Host
+	*
+	* @param params 包含 skillName 的参数
+	* @returns Skill 文件内容
+	*/
+	async getMarketplaceSkillContent(params) {
+		this.log("Getting marketplace skill content:", params.skillName);
+		try {
+			const response = await this.sharedAcpClient.sendBroadcastRequest("getMarketplaceSkillContent", { skillName: params.skillName });
+			this.log("getMarketplaceSkillContent() response:", response);
+			return {
+				content: response?.content ?? "",
+				error: response?.error
+			};
+		} catch (error) {
+			this.log("getMarketplaceSkillContent() failed:", error);
+			return {
+				content: "",
+				error: error instanceof Error ? error.message : "Unknown error"
+			};
+		}
+	}
+	/**
+	* 安装市场 Skill 到用户目录
+	* 通过 shared ACP client 发送广播请求到 Extension Host
+	*
+	* @param params 包含 skillName 的参数
+	* @returns 安装结果
+	*/
+	async installMarketplaceSkill(params) {
+		this.log("Installing marketplace skill:", params.skillName);
+		try {
+			const response = await this.sharedAcpClient.sendBroadcastRequest("installMarketplaceSkill", { skillName: params.skillName });
+			this.log("installMarketplaceSkill() response:", response);
+			return {
+				success: response?.success ?? false,
+				skillName: response?.skillName ?? params.skillName,
+				errorMessage: response?.errorMessage
+			};
+		} catch (error) {
+			this.log("installMarketplaceSkill() failed:", error);
+			return {
+				success: false,
+				skillName: params.skillName,
+				errorMessage: error instanceof Error ? error.message : "Unknown error"
+			};
+		}
+	}
+	/**
+	* 批量切换插件状态
+	* 通过 ACP 协议调用 Extension Host 的 PluginService
+	*
+	* @param request 批量插件操作请求
+	* @returns 批量操作结果
+	*/
+	async batchTogglePlugins(request) {
+		this.log("Batch toggling plugins:", request);
+		try {
+			const result = await this.sharedAcpClient.batchTogglePlugins(request);
+			this.log("batchTogglePlugins() response:", result);
+			return {
+				success: result.success,
+				succeededPlugins: result.succeededPlugins,
+				failedPlugins: result.failedPlugins.map((item) => ({
+					pluginName: item.pluginName,
+					marketplaceName: item.marketplaceName,
+					scope: item.scope,
+					operation: item.operation,
+					error: item.error ?? "Unknown error"
+				}))
+			};
+		} catch (error) {
+			this.log("batchTogglePlugins() failed:", error);
+			return {
+				success: false,
+				succeededPlugins: [],
+				failedPlugins: request.items.map((item) => ({
+					...item,
+					error: error instanceof Error ? error.message : "Unknown error"
+				}))
+			};
+		}
+	}
+	/**
+	* 获取当前工作区列表
+	* 这是 LocalAgentProvider 特有的能力，通过 shared ACP client 发送请求，
+	* 使用 __workspace__ session ID，由 Main Process 直接处理
+	*
+	* @param filter 可选的过滤参数
+	* @returns 工作区列表
+	*/
+	async getCurrentWorkspaces(filter) {
+		this.log("Getting current workspaces:", filter);
+		try {
+			return (await this.sharedAcpClient.getCurrentWorkspaces({ filter })).workspaces ?? [];
+		} catch (error) {
+			this.log("getCurrentWorkspaces() failed:", error);
+			return [];
+		}
+	}
+	async getAutomationSnapshot() {
+		this.log("Getting automation snapshot");
+		return await this.sharedAcpClient.getAutomationSnapshot();
+	}
+	async updateAutomation(payload) {
+		this.log("Updating automation:", payload?.id || payload?.name || "(new)");
+		return await this.sharedAcpClient.updateAutomation(payload);
+	}
+	async deleteAutomation(id) {
+		this.log("Deleting automation:", id);
+		return await this.sharedAcpClient.deleteAutomation({ id });
+	}
+	async archiveAutomationInboxItem(itemId) {
+		this.log("Archiving automation inbox item:", itemId);
+		return await this.sharedAcpClient.archiveAutomationInboxItem({ itemId });
+	}
+	async deleteAutomationInboxItem(itemId) {
+		this.log("Deleting automation inbox item:", itemId);
+		return await this.sharedAcpClient.deleteAutomationInboxItem({ itemId });
+	}
+	async testAutomation(id) {
+		this.log("Testing automation:", id);
+		return await this.sharedAcpClient.testAutomation({ id });
+	}
+	/**
+	* 获取已安装插件列表
+	* 通过 shared ACP client 发送请求
+	*
+	* @param forceRefresh 是否强制刷新缓存
+	* @returns 已安装插件列表
+	*/
+	async getInstalledPlugins(forceRefresh) {
+		this.log("Getting installed plugins, forceRefresh:", forceRefresh);
+		try {
+			const result = await this.sharedAcpClient.getInstalledPlugins({ forceRefresh });
+			this.log(`Got ${result.plugins?.length ?? 0} installed plugins`);
+			return result.plugins ?? [];
+		} catch (error) {
+			this.log("getInstalledPlugins() failed:", error);
+			return [];
+		}
+	}
+	/**
+	* 安装插件
+	* 通过 shared ACP client 发送请求
+	*
+	* @param pluginNames 插件名称数组
+	* @param marketplaceName 插件市场名称
+	* @param installScope 安装范围
+	* @param marketplaceSource 市场源地址（当市场不存在时用于自动添加市场）
+	* @returns 安装结果
+	*/
+	async installPlugins(pluginNames, marketplaceName, installScope, marketplaceSource, workspacePath) {
+		this.log("Installing plugins:", pluginNames, "from", marketplaceName, marketplaceSource ? `(source: ${marketplaceSource})` : "", workspacePath ? `(workspacePath: ${workspacePath})` : "");
+		try {
+			return await this.sharedAcpClient.installPlugins({
+				pluginNames,
+				marketplaceName,
+				installScope,
+				marketplaceSource,
+				workspacePath
+			});
+		} catch (error) {
+			this.log("installPlugins() failed:", error);
+			return {
+				success: false,
+				error: error instanceof Error ? error.message : "Unknown error"
+			};
+		}
+	}
+	/**
+	* 卸载插件
+	* 通过 shared ACP client 发送请求
+	*
+	* @param pluginName 插件名称
+	* @param marketplaceName 插件市场名称
+	* @param scope 卸载范围
+	* @returns 卸载结果
+	*/
+	async uninstallPlugin(pluginName, marketplaceName, scope) {
+		this.log("Uninstalling plugin:", pluginName, "from", marketplaceName, "scope:", scope);
+		try {
+			return await this.sharedAcpClient.uninstallPlugin({
+				pluginName,
+				marketplaceName,
+				scope
+			});
+		} catch (error) {
+			this.log("uninstallPlugin() failed:", error);
+			return {
+				success: false,
+				error: error instanceof Error ? error.message : "Unknown error"
+			};
+		}
+	}
+	/**
+	* 更新插件到最新版本
+	* 通过 shared ACP client 发送请求
+	*
+	* @param pluginName 插件名称
+	* @param marketplaceName 插件市场名称
+	* @returns 更新结果
+	*/
+	async updatePlugin(pluginName, marketplaceName) {
+		this.log("Updating plugin:", pluginName, "from", marketplaceName);
+		try {
+			return await this.sharedAcpClient.updatePlugin({
+				pluginName,
+				marketplaceName
+			});
+		} catch (error) {
+			this.log("updatePlugin() failed:", error);
+			return {
+				success: false,
+				error: error instanceof Error ? error.message : "Unknown error"
+			};
+		}
+	}
+	/**
+	* 获取插件市场列表
+	* 通过 shared ACP client 发送请求
+	*
+	* @param forceRefresh 是否强制刷新缓存
+	* @returns 插件市场列表
+	*/
+	async getPluginMarketplaces(forceRefresh) {
+		this.log("Getting plugin marketplaces, forceRefresh:", forceRefresh);
+		try {
+			const result = await this.sharedAcpClient.getPluginMarketplaces({ forceRefresh });
+			this.log(`Got ${result.marketplaces?.length ?? 0} marketplaces`);
+			return result.marketplaces ?? [];
+		} catch (error) {
+			this.log("getPluginMarketplaces() failed:", error);
+			return [];
+		}
+	}
+	/**
+	* 获取市场下的插件列表
+	* 通过 shared ACP client 发送请求
+	*
+	* @param marketplaceName 市场名称
+	* @param forceRefresh 是否强制刷新缓存
+	* @param searchText 搜索关键词
+	* @returns 插件列表
+	*/
+	async getMarketplacePlugins(marketplaceName, forceRefresh, searchText) {
+		this.log("Getting marketplace plugins:", marketplaceName, "forceRefresh:", forceRefresh, "searchText:", searchText);
+		try {
+			const result = await this.sharedAcpClient.getMarketplacePlugins({
+				marketplaceName,
+				forceRefresh,
+				searchText
+			});
+			this.log(`Got ${result.plugins?.length ?? 0} plugins from marketplace ${marketplaceName}`);
+			return result.plugins ?? [];
+		} catch (error) {
+			this.log("getMarketplacePlugins() failed:", error);
+			return [];
+		}
+	}
+	/**
+	* 获取插件详情
+	* 通过 shared ACP client 发送请求
+	*
+	* @param pluginName 插件名称
+	* @param marketplaceName 市场名称
+	* @returns 插件详情
+	*/
+	async getPluginDetail(pluginName, marketplaceName) {
+		this.log("Getting plugin detail:", pluginName, "from", marketplaceName);
+		try {
+			return (await this.sharedAcpClient.getPluginDetail({
+				pluginName,
+				marketplaceName
+			})).plugin ?? null;
+		} catch (error) {
+			this.log("getPluginDetail() failed:", error);
+			return null;
+		}
+	}
+	/**
+	* 添加插件市场
+	* 通过 shared ACP client 发送请求
+	*
+	* @param source 市场源 URL 或 GitHub repo
+	* @param name 市场名称（可选）
+	* @returns 添加结果
+	*/
+	async addPluginMarketplace(source, name) {
+		this.log("Adding plugin marketplace:", source, name ? `as ${name}` : "");
+		try {
+			return await this.sharedAcpClient.addPluginMarketplace({
+				source,
+				name
+			});
+		} catch (error) {
+			this.log("addPluginMarketplace() failed:", error);
+			return {
+				success: false,
+				error: error instanceof Error ? error.message : "Unknown error"
+			};
+		}
+	}
+	/**
+	* 删除插件市场
+	* 通过 shared ACP client 发送请求
+	*
+	* @param marketplaceName 市场名称
+	* @returns 删除结果
+	*/
+	async removePluginMarketplace(marketplaceName) {
+		this.log("Removing plugin marketplace:", marketplaceName);
+		try {
+			return await this.sharedAcpClient.removePluginMarketplace({ marketplaceName });
+		} catch (error) {
+			this.log("removePluginMarketplace() failed:", error);
+			return {
+				success: false,
+				error: error instanceof Error ? error.message : "Unknown error"
+			};
+		}
+	}
+	/**
+	* 刷新插件市场
+	* 通过 shared ACP client 发送请求
+	*
+	* @param marketplaceName 市场名称
+	* @returns 刷新结果
+	*/
+	async refreshPluginMarketplace(marketplaceName) {
+		this.log("Refreshing plugin marketplace:", marketplaceName);
+		try {
+			return await this.sharedAcpClient.refreshPluginMarketplace({ marketplaceName });
+		} catch (error) {
+			this.log("refreshPluginMarketplace() failed:", error);
+			return {
+				success: false,
+				error: error instanceof Error ? error.message : "Unknown error"
+			};
+		}
+	}
+	/**
+	* 用新窗口打开文件夹
+	* 通过 shared ACP client 发送请求到 Extension Host
+	*
+	* 调用链：
+	* 1. client.sessions.openFolderInNewWindow() 调用此方法
+	* 2. LocalAgentProvider -> AcpJsonRpcClient.openFolderInNewWindow()
+	* 3. Extension Host -> PluginService.openFolderInNewWindow()
+	* 4. VS Code 执行 vscode.openFolder 命令
+	*
+	* @param folderPath 文件夹路径
+	*/
+	async openFolderInNewWindow(folderPath) {
+		this.log("Opening folder in new window:", folderPath);
+		try {
+			await this.sharedAcpClient.openFolderInNewWindow({ folderPath });
+		} catch (error) {
+			this.log("openFolderInNewWindow() failed:", error);
+			throw error;
+		}
+	}
+	/**
+	* 在系统文件管理器中打开目录
+	* 通过 __backend__ 路由到 BackendService → Main Process → shell.openPath
+	*
+	* @param folderPath 文件夹路径
+	*/
+	async openFolder(folderPath) {
+		this.log("Opening folder in system file manager:", folderPath);
+		try {
+			const response = await this.channel.callMethod("__backend__", {
+				type: "backend",
+				requestId: `req-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+				params: {
+					type: "backend:open-folder",
+					params: { folderPath }
+				}
+			}, 1e4);
+			this.log("openFolder() response:", response.data);
+			return response.data;
+		} catch (error) {
+			this.log("openFolder() failed:", error);
+			throw error;
+		}
+	}
+	/**
+	* 获取支持的场景列表（从后端 API）
+	* 通过 shared ACP client 发送请求到 Extension Host
+	* 用于 Welcome 页面的 QuickActions 快捷操作
+	*
+	* 调用链：
+	* 1. client.sessions.getSupportScenes() 调用此方法
+	* 2. LocalAgentProvider -> AcpJsonRpcClient.getSupportScenes()
+	* 3. Extension Host 调用 RestOperations -> GET /v2/as/support/scenes
+	* 4. 返回 SupportSceneInfo[] 数据
+	*
+	* @param locale - 可选，语言环境（如 'zh-CN', 'en-US'），用于获取对应语言的场景数据
+	* @returns 支持的场景列表
+	*/
+	async getSupportScenes(locale) {
+		this.log("Getting support scenes", locale ? `with locale: ${locale}` : "");
+		try {
+			const result = await this.sharedAcpClient.getSupportScenes({ locale });
+			this.log(`Got ${result.scenes?.length ?? 0} support scenes`);
+			return result.scenes ?? [];
+		} catch (error) {
+			this.log("getSupportScenes() failed:", error);
+			return [];
+		}
+	}
+	/**
+	* 获取产品配置中的场景列表
+	* 通过 BackendService 的 __backend__ session 路由到 Main Process 直接读取本地 scenes.json 文件
+	* 无需等待 Extension Host 初始化，页面打开时即可快速加载
+	*
+	* 调用链：
+	* 1. LocalAgentProvider.getProductScenes()
+	* 2. channel.callMethod('__backend__', ...) → BackendService.getProductScenes()
+	* 3. ipcRenderer.invoke('codebuddy:getProductScenes') → Main Process
+	* 4. fs.readFile(~/.codebuddy/plugins/marketplaces/cb_teams_marketplace/scenes.json)
+	* 5. 返回 SupportSceneInfo[] 数据
+	*
+	* @param locale - 可选，语言环境
+	* @returns 产品配置中的场景列表
+	*/
+	async getProductScenes(locale) {
+		this.log("Getting product scenes", locale ? `with locale: ${locale}` : "");
+		try {
+			const scenes = (await this.channel.callMethod("__backend__", {
+				type: "backend",
+				requestId: `req-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+				params: {
+					type: "backend:get-product-scenes",
+					params: { locale }
+				}
+			}, 1e4)).data?.scenes ?? [];
+			this.log(`Got ${scenes.length} product scenes`);
+			return scenes;
+		} catch (error) {
+			this.log("getProductScenes() failed:", error);
+			return [];
+		}
+	}
+	/**
+	* 获取会话的可用命令列表
+	* 通过 shared ACP client 发送请求到 Extension Host
+	* 如果 session.availableCommands 有值则返回缓存值，否则从后端获取
+	*
+	* 调用链：
+	* 1. client.sessions.getAvailableCommands(params) 调用此方法
+	* 2. LocalAgentProvider -> AcpJsonRpcClient.sendRequest()
+	* 3. Extension Host 返回命令列表
+	*
+	* @param params - 命令获取参数
+	* @returns 可用命令列表
+	*/
+	async getAvailableCommands(params) {
+		this.log("Getting available commands for session:", params?.sessionId ?? "(default)");
+		try {
+			let result;
+			if (params?.sessionId) result = await this.sharedAcpClient.sendRequest(params.sessionId, "getAvailableCommands", params);
+			else result = await this.sharedAcpClient.sendBroadcastRequest("getAvailableCommands", params || {});
+			this.log(`Got ${result.availableCommands?.length ?? 0} available commands`);
+			return result.availableCommands ?? [];
+		} catch (error) {
+			this.log("getAvailableCommands() failed:", error);
+			return [];
+		}
+	}
+	async requestYieldAfterCurrentStep(sessionId) {
+		this.log(`requestYieldAfterCurrentStep() called: sessionId=${sessionId}`);
+		try {
+			const accepted = !!(await this.sharedAcpClient.sendRequest(sessionId, "requestYieldAfterCurrentStep", { sessionId }))?.accepted;
+			this.log(`requestYieldAfterCurrentStep() completed: sessionId=${sessionId}, accepted=${accepted}`);
+			return accepted;
+		} catch (error) {
+			this.log("requestYieldAfterCurrentStep() failed:", error);
+			return false;
+		}
+	}
+	/**
+	* 上报 telemetry 事件
+	* 通过 ACP 链路发送到 IDE 端，由 AcpAgentImpl → EventService 完成上报
+	*/
+	async reportTelemetry(eventName, payload) {
+		try {
+			await this.sharedAcpClient.sendBroadcastRequest("reportTelemetry", {
+				eventName,
+				payload
+			});
+		} catch (error) {
+			this.log("reportTelemetry() failed:", error);
+		}
+	}
+	/**
+	* 设置 MCP 事件监听器
+	* 只需要设置一次，用于接收后端推送的确认请求
+	*/
+	setupMcpEventListeners() {
+		if (this.mcpEventListenersSetup) return;
+		this.mcpEventListenersSetup = true;
+		this.channel.on("mcp-sampling-confirm-request", (data) => {
+			this.log("[MCP] Received sampling confirm request:", data);
+			const serverName = data?.serverName;
+			if (serverName) this.samplingRequestCallbacks.get(serverName)?.forEach((callback) => {
+				try {
+					callback(data);
+				} catch (error) {
+					this.log("[MCP] Sampling callback error:", error);
+				}
+			});
+		});
+		this.channel.on("mcp-roots-confirm-request", (data) => {
+			this.log("[MCP] Received roots confirm request:", data);
+			const serverName = data?.serverName;
+			if (serverName) this.rootsRequestCallbacks.get(serverName)?.forEach((callback) => {
+				try {
+					callback(data);
+				} catch (error) {
+					this.log("[MCP] Roots callback error:", error);
+				}
+			});
+		});
+		this.log("[MCP] Event listeners setup completed");
+	}
+	/**
+	* 响应 MCP Sampling 确认请求
+	* 将用户的决策发送到后端
+	*
+	* @param sessionId 会话 ID
+	* @param response Sampling 确认响应
+	*/
+	async respondToSampling(sessionId, response) {
+		this.log(`respondToSampling() called: sessionId=${sessionId}, requestId=${response.id}, approved=${response.approved}`);
+		try {
+			await this.sharedAcpClient.sendRequest(sessionId, "respondToSampling", {
+				sessionId,
+				...response
+			});
+			this.log(`respondToSampling() completed for request: ${response.id}`);
+		} catch (error) {
+			this.log("respondToSampling() failed:", error);
+			throw error;
+		}
+	}
+	/**
+	* 响应 MCP Roots 确认请求
+	* 将用户的决策发送到后端
+	*
+	* @param sessionId 会话 ID
+	* @param response Roots 确认响应
+	*/
+	async respondToRoots(sessionId, response) {
+		this.log(`respondToRoots() called: sessionId=${sessionId}, requestId=${response.id}, approved=${response.approved}`);
+		try {
+			await this.sharedAcpClient.sendRequest(sessionId, "respondToRoots", {
+				sessionId,
+				...response
+			});
+			this.log(`respondToRoots() completed for request: ${response.id}`);
+		} catch (error) {
+			this.log("respondToRoots() failed:", error);
+			throw error;
+		}
+	}
+	/**
+	* 订阅 MCP Sampling 确认请求
+	* 当 MCP 服务器发起 Sampling 请求时触发回调
+	*
+	* @param serverName MCP 服务器名称
+	* @param callback 请求回调
+	* @returns 取消订阅函数
+	*/
+	subscribeSamplingRequests(serverName, callback) {
+		this.log(`subscribeSamplingRequests() called for server: ${serverName}`);
+		this.setupMcpEventListeners();
+		let callbacks = this.samplingRequestCallbacks.get(serverName);
+		if (!callbacks) {
+			callbacks = /* @__PURE__ */ new Set();
+			this.samplingRequestCallbacks.set(serverName, callbacks);
+		}
+		callbacks.add(callback);
+		return () => {
+			this.log(`Unsubscribing sampling requests for server: ${serverName}`);
+			const cbs = this.samplingRequestCallbacks.get(serverName);
+			cbs?.delete(callback);
+			if (cbs?.size === 0) this.samplingRequestCallbacks.delete(serverName);
+		};
+	}
+	/**
+	* 订阅 MCP Roots 确认请求
+	* 当 MCP 服务器发起 Roots 请求时触发回调
+	*
+	* @param serverName MCP 服务器名称
+	* @param callback 请求回调
+	* @returns 取消订阅函数
+	*/
+	subscribeRootsRequests(serverName, callback) {
+		this.log(`subscribeRootsRequests() called for server: ${serverName}`);
+		this.setupMcpEventListeners();
+		let callbacks = this.rootsRequestCallbacks.get(serverName);
+		if (!callbacks) {
+			callbacks = /* @__PURE__ */ new Set();
+			this.rootsRequestCallbacks.set(serverName, callbacks);
+		}
+		callbacks.add(callback);
+		return () => {
+			this.log(`Unsubscribing roots requests for server: ${serverName}`);
+			const cbs = this.rootsRequestCallbacks.get(serverName);
+			cbs?.delete(callback);
+			if (cbs?.size === 0) this.rootsRequestCallbacks.delete(serverName);
+		};
+	}
+	/**
+	* 获取灵感卡片列表
+	*
+	* @param query - 查询参数（分页、分类、日期筛选等）
+	* @returns 灵感卡片列表结果
+	*/
+	async getInspirations(query) {
+		this.log("getInspirations() called:", query);
+		try {
+			const response = await this.channel.callMethod("__backend__", {
+				type: "backend",
+				requestId: `req-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+				params: {
+					type: "backend:inspiration-list",
+					params: query
+				}
+			}, 1e4);
+			this.log("getInspirations() response:", response.data);
+			return response.data;
+		} catch (error) {
+			this.log("getInspirations() failed:", error);
+			return {
+				cards: [],
+				total: 0
+			};
+		}
+	}
+	/**
+	* 获取灵感卡片详情
+	*
+	* @param params - 包含 cardId 的参数
+	* @returns 灵感卡片详情
+	*/
+	async getInspirationDetail(params) {
+		this.log("getInspirationDetail() called:", params);
+		try {
+			const response = await this.channel.callMethod("__backend__", {
+				type: "backend",
+				requestId: `req-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+				params: {
+					type: "backend:inspiration-detail",
+					params
+				}
+			}, 5e3);
+			this.log("getInspirationDetail() response:", response.data);
+			return response.data;
+		} catch (error) {
+			this.log("getInspirationDetail() failed:", error);
+			return;
+		}
+	}
+	/**
+	* 标记灵感卡片为已读
+	*
+	* @param params - 包含 cardId 的参数
+	* @returns 操作结果
+	*/
+	async markInspirationRead(params) {
+		this.log("markInspirationRead() called:", params);
+		try {
+			return (await this.channel.callMethod("__backend__", {
+				type: "backend",
+				requestId: `req-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+				params: {
+					type: "backend:inspiration-mark-read",
+					params
+				}
+			}, 5e3)).data;
+		} catch (error) {
+			this.log("markInspirationRead() failed:", error);
+			return { success: false };
+		}
+	}
+	/**
+	* 对灵感卡片提交反馈
+	*
+	* @param feedback - 反馈数据（cardId、feedbackType 等）
+	* @returns 操作结果
+	*/
+	async addInspirationFeedback(feedback) {
+		this.log("addInspirationFeedback() called:", feedback);
+		try {
+			return (await this.channel.callMethod("__backend__", {
+				type: "backend",
+				requestId: `req-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+				params: {
+					type: "backend:inspiration-feedback",
+					params: feedback
+				}
+			}, 5e3)).data;
+		} catch (error) {
+			this.log("addInspirationFeedback() failed:", error);
+			return { success: false };
+		}
+	}
+	/**
+	* 收藏/取消收藏灵感卡片
+	*
+	* @param params - 包含 cardId 的参数
+	* @returns 操作结果
+	*/
+	async saveInspiration(params) {
+		this.log("saveInspiration() called:", params);
+		try {
+			return (await this.channel.callMethod("__backend__", {
+				type: "backend",
+				requestId: `req-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+				params: {
+					type: "backend:inspiration-save",
+					params
+				}
+			}, 5e3)).data;
+		} catch (error) {
+			this.log("saveInspiration() failed:", error);
+			return { success: false };
+		}
+	}
+	/**
+	* 获取灵感功能用户配置
+	*
+	* @returns 用户配置
+	*/
+	async getInspirationSettings() {
+		this.log("getInspirationSettings() called");
+		try {
+			const response = await this.channel.callMethod("__backend__", {
+				type: "backend",
+				requestId: `req-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+				params: {
+					type: "backend:inspiration-settings-get",
+					params: {}
+				}
+			}, 5e3);
+			this.log("getInspirationSettings() response:", response.data);
+			return response.data;
+		} catch (error) {
+			this.log("getInspirationSettings() failed:", error);
+			return {};
+		}
+	}
+	/**
+	* 保存灵感功能用户配置
+	*
+	* @param config - 用户配置数据
+	* @returns 操作结果
+	*/
+	async saveInspirationSettings(config) {
+		this.log("saveInspirationSettings() called:", config);
+		try {
+			return (await this.channel.callMethod("__backend__", {
+				type: "backend",
+				requestId: `req-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+				params: {
+					type: "backend:inspiration-settings-save",
+					params: config
+				}
+			}, 5e3)).data;
+		} catch (error) {
+			this.log("saveInspirationSettings() failed:", error);
+			return { success: false };
+		}
+	}
+	/**
+	* 检查灵感引导是否完成
+	*
+	* @returns 引导完成状态
+	*/
+	async checkInspirationOnboarding() {
+		this.log("checkInspirationOnboarding() called");
+		try {
+			return (await this.channel.callMethod("__backend__", {
+				type: "backend",
+				requestId: `req-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+				params: {
+					type: "backend:inspiration-onboarding-check",
+					params: {}
+				}
+			}, 5e3)).data;
+		} catch (error) {
+			this.log("checkInspirationOnboarding() failed:", error);
+			return { completed: false };
+		}
+	}
+	/**
+	* 完成灵感引导
+	*
+	* @returns 操作结果
+	*/
+	async completeInspirationOnboarding() {
+		this.log("completeInspirationOnboarding() called");
+		try {
+			return (await this.channel.callMethod("__backend__", {
+				type: "backend",
+				requestId: `req-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+				params: {
+					type: "backend:inspiration-onboarding-complete",
+					params: {}
+				}
+			}, 5e3)).data;
+		} catch (error) {
+			this.log("completeInspirationOnboarding() failed:", error);
+			return { success: false };
+		}
+	}
+	/**
+	* 注入 demo 灵感卡片（首次引导完成后调用）
+	*
+	* @returns 操作结果
+	*/
+	async injectDemoInspirationCards() {
+		this.log("injectDemoInspirationCards() called");
+		try {
+			return (await this.channel.callMethod("__backend__", {
+				type: "backend",
+				requestId: `req-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+				params: {
+					type: "backend:inspiration-inject-demo",
+					params: {}
+				}
+			}, 1e4)).data;
+		} catch (error) {
+			this.log("injectDemoInspirationCards() failed:", error);
+			return { success: false };
+		}
+	}
+	/**
+	* 添加灵感策展指令
+	*
+	* @param params - 策展指令数据
+	* @returns 操作结果
+	*/
+	async addInspirationCuration(params) {
+		this.log("addInspirationCuration() called:", params);
+		try {
+			return (await this.channel.callMethod("__backend__", {
+				type: "backend",
+				requestId: `req-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+				params: {
+					type: "backend:inspiration-curation-add",
+					params
+				}
+			}, 5e3)).data;
+		} catch (error) {
+			this.log("addInspirationCuration() failed:", error);
+			return { success: false };
+		}
+	}
+	/**
+	* 获取灵感策展指令列表
+	*
+	* @returns 策展指令列表
+	*/
+	async listInspirationCurations() {
+		this.log("listInspirationCurations() called");
+		try {
+			const response = await this.channel.callMethod("__backend__", {
+				type: "backend",
+				requestId: `req-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+				params: {
+					type: "backend:inspiration-curation-list",
+					params: {}
+				}
+			}, 5e3);
+			this.log("listInspirationCurations() response:", response.data);
+			return response.data;
+		} catch (error) {
+			this.log("listInspirationCurations() failed:", error);
+			return { directives: [] };
+		}
+	}
+	/**
+	* 更新灵感策展指令
+	*
+	* @param params - 包含 directiveId 和更新字段的参数
+	* @returns 操作结果
+	*/
+	async updateInspirationCuration(params) {
+		this.log("updateInspirationCuration() called:", params);
+		try {
+			return (await this.channel.callMethod("__backend__", {
+				type: "backend",
+				requestId: `req-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+				params: {
+					type: "backend:inspiration-curation-update",
+					params
+				}
+			}, 5e3)).data;
+		} catch (error) {
+			this.log("updateInspirationCuration() failed:", error);
+			return { success: false };
+		}
+	}
+	/**
+	* 删除灵感策展指令
+	*
+	* @param params - 包含 directiveId 的参数
+	* @returns 操作结果
+	*/
+	async deleteInspirationCuration(params) {
+		this.log("deleteInspirationCuration() called:", params);
+		try {
+			return (await this.channel.callMethod("__backend__", {
+				type: "backend",
+				requestId: `req-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+				params: {
+					type: "backend:inspiration-curation-delete",
+					params
+				}
+			}, 5e3)).data;
+		} catch (error) {
+			this.log("deleteInspirationCuration() failed:", error);
+			return { success: false };
+		}
+	}
+	/**
+	* 生成灵感测试数据
+	*
+	* @returns 生成结果
+	*/
+	async generateInspirationTestData() {
+		this.log("generateInspirationTestData() called");
+		try {
+			const response = await this.channel.callMethod("__backend__", {
+				type: "backend",
+				requestId: `req-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+				params: {
+					type: "backend:inspiration-generate-test-data",
+					params: {}
+				}
+			}, 1e4);
+			this.log("generateInspirationTestData() response:", response.data);
+			return response.data;
+		} catch (error) {
+			this.log("generateInspirationTestData() failed:", error);
+			return { success: false };
+		}
+	}
+	/**
+	* 获取已有连接
+	*
+	* @param cwd - 工作区路径
+	* @returns LocalAgentConnection 实例或 undefined
+	*/
+	getConnection(cwd) {
+		return this.connections.get(cwd);
+	}
+	/**
+	* 检查是否存在连接
+	*
+	* @param cwd - 工作区路径
+	* @returns 是否存在连接
+	*/
+	hasConnection(cwd) {
+		return this.connections.has(cwd);
+	}
+	/**
+	* 断开所有连接
+	*/
+	disconnectAll() {
+		for (const connection of this.connections.values()) connection.disconnect();
+		this.connections.clear();
+		this.sessionCwdMap.clear();
+		for (const fs of this.filesystemCache.values()) fs.destroy();
+		this.filesystemCache.clear();
+		this.samplingRequestCallbacks.clear();
+		this.rootsRequestCallbacks.clear();
+	}
+	/**
+	* 获取 Filesystem 实例
+	*
+	* 对于 Local 模式，agentId 实际上是 sessionId
+	* 通过已有的 MessagePort 通道将 filesystem 请求路由到 ExtensionHost
+	*
+	* @param agentId - Session ID（对于 Local 模式）
+	* @returns FilesResource 实例
+	*/
+	async getFilesystem(agentId) {
+		this.log(`getFilesystem() called with: ${agentId}`);
+		const cached = this.filesystemCache.get(agentId);
+		if (cached) {
+			this.log(`Returning cached filesystem for: ${agentId}`);
+			return cached;
+		}
+		const filesystem = new LocalFilesystem(this.sharedAcpClient, agentId, { debug: this.options.debug });
+		this.filesystemCache.set(agentId, filesystem);
+		this.log(`Created new filesystem for: ${agentId}`);
+		return filesystem;
+	}
+	/**
+	* Register an event listener
+	* Forwards to the underlying channel's event system
+	*
+	* @param event - Event name
+	* @param handler - Event handler function
+	*/
+	on(event, handler) {
+		this.channel.on(event, handler);
+		this.log(`Registered event listener: ${event}`);
+	}
+	/**
+	* Unregister an event listener
+	* Forwards to the underlying channel's event system
+	*
+	* @param event - Event name
+	* @param handler - Event handler function to remove
+	*/
+	off(event, handler) {
+		this.channel.off(event, handler);
+		this.log(`Unregistered event listener: ${event}`);
+	}
+	/**
+	* 获取 MCP 服务器列表
+	* 通过 shared ACP client 发送广播请求到 Extension Host
+	*
+	* @returns MCP 服务器列表
+	*/
+	async getMcpServers() {
+		this.log("Getting MCP servers");
+		try {
+			const result = await this.sharedAcpClient.sendBroadcastRequest("getMcpServers", {});
+			this.log(`Got ${result.servers?.length ?? 0} MCP servers`);
+			return result.servers ?? [];
+		} catch (error) {
+			this.log("getMcpServers() failed:", error);
+			return [];
+		}
+	}
+	/**
+	* 切换 MCP 服务器启用/禁用状态
+	* 通过 shared ACP client 发送广播请求到 Extension Host
+	*
+	* @param serverName 服务器名称
+	* @param enabled 是否启用
+	*/
+	async toggleMcpServer(serverName, enabled) {
+		this.log(`Toggling MCP server: ${serverName}, enabled: ${enabled}`);
+		try {
+			await this.sharedAcpClient.sendBroadcastRequest("toggleMcpServer", {
+				serverName,
+				enabled
+			});
+			this.log(`toggleMcpServer() completed for: ${serverName}`);
+		} catch (error) {
+			this.log("toggleMcpServer() failed:", error);
+			throw error;
+		}
+	}
+	/**
+	* 重新连接 MCP 服务器
+	* 通过 shared ACP client 发送广播请求到 Extension Host
+	*
+	* @param serverName 服务器名称
+	* @param forceHttpCallback 是否强制使用 HTTP 回调（忽略 mcpSchemaUrl 配置）
+	*/
+	async reconnectMcpServer(serverName, forceHttpCallback) {
+		this.log(`Reconnecting MCP server: ${serverName}, forceHttpCallback: ${forceHttpCallback}`);
+		try {
+			await this.sharedAcpClient.sendBroadcastRequest("reconnectMcpServer", {
+				serverName,
+				forceHttpCallback
+			});
+			this.log(`reconnectMcpServer() completed for: ${serverName}`);
+		} catch (error) {
+			this.log("reconnectMcpServer() failed:", error);
+			throw error;
+		}
+	}
+	/**
+	* 删除 MCP 服务器配置
+	* 通过 shared ACP client 发送广播请求到 Extension Host
+	*
+	* @param serverName 服务器名称
+	*/
+	async deleteMcpServer(serverName) {
+		this.log(`Deleting MCP server: ${serverName}`);
+		try {
+			await this.sharedAcpClient.sendBroadcastRequest("deleteMcpServer", { serverName });
+			this.log(`deleteMcpServer() completed for: ${serverName}`);
+		} catch (error) {
+			this.log("deleteMcpServer() failed:", error);
+			throw error;
+		}
+	}
+	/**
+	* 打开 MCP 配置文件
+	* 通过 shared ACP client 发送广播请求到 Extension Host
+	* Extension Host 调用 VS Code 命令打开配置文件
+	*/
+	async openMcpConfig() {
+		this.log("Opening MCP config");
+		try {
+			await this.sharedAcpClient.sendBroadcastRequest("openMcpConfig", {});
+			this.log("openMcpConfig() completed");
+		} catch (error) {
+			this.log("openMcpConfig() failed:", error);
+			throw error;
+		}
+	}
+	/**
+	* 获取 MCP 配置文件内容
+	* 通过 shared ACP client 发送广播请求到 Extension Host
+	* @returns 配置文件路径和内容
+	*/
+	async getMcpConfigContent() {
+		this.log("Getting MCP config content");
+		try {
+			const result = await this.sharedAcpClient.sendBroadcastRequest("getMcpConfigContent", {});
+			this.log("getMcpConfigContent() completed:", result.filePath);
+			return result;
+		} catch (error) {
+			this.log("getMcpConfigContent() failed:", error);
+			throw error;
+		}
+	}
+	/**
+	* 保存 MCP 配置文件内容
+	* 通过 shared ACP client 发送广播请求到 Extension Host
+	* @param content 新的配置内容
+	*/
+	async saveMcpConfigContent(content) {
+		this.log("Saving MCP config content");
+		try {
+			await this.sharedAcpClient.sendBroadcastRequest("saveMcpConfigContent", { content });
+			this.log("saveMcpConfigContent() completed");
+		} catch (error) {
+			this.log("saveMcpConfigContent() failed:", error);
+			throw error;
+		}
+	}
+	/**
+	* 读取系统剪贴板文本
+	* 通过 shared ACP client 发送广播请求到 Extension Host
+	* @returns 剪贴板文本内容
+	*/
+	async clipboardReadText() {
+		this.log("Reading clipboard text");
+		try {
+			const result = await this.sharedAcpClient.sendBroadcastRequest("clipboardReadText", {});
+			this.log("clipboardReadText() completed");
+			return result?.text ?? "";
+		} catch (error) {
+			this.log("clipboardReadText() failed:", error);
+			throw error;
+		}
+	}
+	log(...args) {
+		if (this.options.debug) console.log("[LocalAgentProvider]", ...args);
+	}
+};
+
+//#endregion
+//#region ../agent-provider/src/common/client/session.ts
+/**
+* ActiveSessionImpl - Implements the ActiveSession interface
+*
+* This class wraps an AgentConnection and provides the session-centric API.
+* It is created by SessionManager when creating or loading sessions.
+*
+* @example
+* ```typescript
+* // Created by client.sessions.new() or client.sessions.load()
+* const session = await client.sessions.new({ cwd: '/workspace' });
+*
+* // Access agent state
+* console.log(session.agentState.status);
+*
+* // Send prompt
+* const response = await session.prompts.send({ content: 'Hello!' });
+*
+* // Cleanup
+* session.disconnect();
+* ```
+*/
+var ActiveSessionImpl = class {
+	/**
+	* Create an ActiveSessionImpl instance
+	*
+	* @param sessionId - Session ID
+	* @param agentId - Agent ID
+	* @param connection - Already connected AgentConnection
+	* @param options - Additional options
+	*/
+	constructor(sessionId, agentId, connection, options = {}) {
+		this._availableCommands = [];
+		this.listeners = /* @__PURE__ */ new Map();
+		this.onceListeners = /* @__PURE__ */ new Map();
+		this.connectionListeners = [];
+		this._id = sessionId;
+		this._agentId = agentId;
+		this.connection = connection;
+		this.logger = options.logger;
+		this._getFilesystem = options.getFilesystem;
+		this._connectionInfo = options.connectionInfo;
+		this.setupConnectionEvents(connection);
+		this.agent = this.createAgentOperations();
+		this.prompts = this.createPromptsResource();
+		this.artifacts = this.createArtifactsResource();
+		this.files = this.createFilesResource();
+	}
+	/**
+	* Session ID
+	*/
+	get id() {
+		return this._id;
+	}
+	/**
+	* Agent ID
+	*/
+	get agentId() {
+		return this._agentId;
+	}
+	/**
+	* Actual workspace path (set from newSession response _meta)
+	*/
+	get cwd() {
+		return this._cwd;
+	}
+	/**
+	* Set actual workspace path (called by SessionManager after createSession)
+	*/
+	setCwd(cwd) {
+		this._cwd = cwd;
+	}
+	/**
+	* Agent state (live connection state)
+	* Returns LocalAgentState or CloudAgentState based on transport type
+	*/
+	get agentState() {
+		return {
+			id: this._agentId,
+			status: this.connection.state,
+			capabilities: this.connection.capabilities,
+			type: this.connection.transport,
+			cwd: this.connection.cwd || ""
+		};
+	}
+	/**
+	* Get agent capabilities (available after connection)
+	*/
+	get capabilities() {
+		return this.connection.capabilities;
+	}
+	/**
+	* Available session modes
+	*/
+	get availableModes() {
+		return this._availableModes;
+	}
+	/**
+	* Current session mode
+	*/
+	get currentMode() {
+		return this._currentMode;
+	}
+	/**
+	* Available models for this session
+	*/
+	get availableModels() {
+		return this._availableModels;
+	}
+	/**
+	* Current model ID
+	*/
+	get currentModelId() {
+		return this._currentModelId;
+	}
+	/**
+	* Available slash commands
+	*
+	* When Agent sends available_commands_update, this list is automatically updated.
+	* Commands can be accessed directly without waiting for events.
+	*/
+	get availableCommands() {
+		return this._availableCommands;
+	}
+	/**
+	* Set available commands (called when available_commands_update is received)
+	*/
+	setAvailableCommands(commands) {
+		this._availableCommands = commands;
+		this.logger?.info(`Session ${this._id}: Available commands updated, count: ${commands.length}`);
+	}
+	/**
+	* Check if the session is active
+	*/
+	get isActive() {
+		return this.connection.isInitialized;
+	}
+	/**
+	* Session connection information (only available for cloud sessions)
+	* 会话连接信息，包括sandboxId、link、token等
+	*/
+	get connectionInfo() {
+		return this._connectionInfo;
+	}
+	/**
+	* Set session modes (called after create/load)
+	*/
+	setModes(availableModes, currentMode) {
+		this._availableModes = availableModes;
+		this._currentMode = currentMode;
+	}
+	/**
+	* Set available models (called after create/load)
+	*/
+	setModels(availableModels, currentModelId) {
+		this._availableModels = availableModels;
+		this._currentModelId = currentModelId;
+	}
+	createAgentOperations() {
+		const self = this;
+		return {
+			get id() {
+				return self._agentId;
+			},
+			get state() {
+				return self.agentState;
+			},
+			get isConnected() {
+				return self.connection.isInitialized;
+			},
+			get capabilities() {
+				return self.connection.capabilities;
+			}
+		};
+	}
+	createPromptsResource() {
+		return {
+			send: async (params) => {
+				const response = await this.getConnectionOrThrow().prompt(this._id, params);
+				return this.mapPromptResponse(response);
+			},
+			stream: (params) => {
+				return this.getConnectionOrThrow().promptStream(this._id, params);
+			},
+			cancel: async () => {
+				await this.getConnectionOrThrow().cancel(this._id);
+			}
+		};
+	}
+	createArtifactsResource() {
+		const notSupported = () => {
+			throw new Error("Artifact management is no longer supported through this API");
+		};
+		return {
+			list: async (_params) => {
+				notSupported();
+				return [];
+			},
+			retrieve: async (_artifactId) => {
+				notSupported();
+			},
+			content: async (_artifactId) => {
+				notSupported();
+				return "";
+			}
+		};
+	}
+	/**
+	* Create files resource with lazy-loaded filesystem
+	*
 	* The filesystem is lazily loaded on first use to avoid unnecessary
 	* connections to the sandbox. The actual filesystem instance is obtained
 	* via the getter function provided by SessionManager.
@@ -18665,6 +22119,7 @@ var ActiveSessionImpl = class {
 */
 var SessionManager = class {
 	constructor(options) {
+		this.pendingConnections = /* @__PURE__ */ new Map();
 		this.provider = options.provider;
 		this.logger = options.logger;
 	}
@@ -18732,11 +22187,76 @@ var SessionManager = class {
 		} else throw new Error("Provider does not support creating agents. Use sessions.load() with an existing sessionId.");
 		const connection = await this.provider.connect(agentId);
 		this.logger?.debug(`Connected to agent: ${agentId}`);
+		let response;
+		try {
+			response = await connection.createSession({
+				_meta: params.options?._meta,
+				cwd: params.cwd,
+				mcpServers: params.options?.mcpServers
+			});
+		} catch (err) {
+			this.pendingConnections.set(agentId, connection);
+			this.logger?.debug(`Cached pending connection for agent: ${agentId}`);
+			if (err instanceof SessionError) throw new SessionError(err.message, err.sessionId, agentId, err.cause instanceof Error ? err.cause : void 0);
+			const cause = err instanceof Error ? err : new Error(String(err));
+			throw new SessionError(`Failed to create session: ${cause.message}`, void 0, agentId, cause);
+		}
+		return this.buildActiveSession(response, agentId, connection, params);
+	}
+	/**
+	* Retry creating a session after initial session/new request failed.
+	*
+	* Use this when `sessions.create()` fails at the `session/new` step
+	* (after agent creation and connection establishment succeeded).
+	* The caller retrieves `agentId` from the thrown `SessionError.agentId`,
+	* then calls this method to re-attempt only the `session/new` request
+	* while reusing the already-initialized connection (no re-connect).
+	*
+	* @experimental This API is subject to change
+	*
+	* @param agentId - Agent ID from the failed SessionError
+	* @param params - Original create session params (cwd, mcpServers, etc.)
+	* @returns ActiveSession on success
+	* @throws SessionError if session/new fails again
+	*
+	* @example
+	* ```typescript
+	* try {
+	*   const session = await client.sessions.create({ cwd: '/workspace' });
+	* } catch (err) {
+	*   if (err instanceof SessionError && err.agentId) {
+	*     // Retry with custom logic
+	*     for (let i = 0; i < 3; i++) {
+	*       try {
+	*         const session = await client.sessions.retryNewSession(err.agentId, { cwd: '/workspace' });
+	*         break; // success
+	*       } catch (retryErr) {
+	*         await new Promise(r => setTimeout(r, 1000 * (i + 1)));
+	*       }
+	*     }
+	*   }
+	* }
+	* ```
+	*/
+	async retryNewSession(agentId, params) {
+		this.logger?.info(`Retrying session/new for agent: ${agentId}`);
+		const connection = this.pendingConnections.get(agentId);
+		if (!connection) throw new SessionError(`No pending connection found for agent: ${agentId}. retryNewSession() can only be called after a failed sessions.create().`, void 0, agentId);
+		this.logger?.debug(`Reusing cached connection for agent: ${agentId}`);
 		const response = await connection.createSession({
 			_meta: params.options?._meta,
 			cwd: params.cwd,
 			mcpServers: params.options?.mcpServers
 		});
+		this.pendingConnections.delete(agentId);
+		this.logger?.debug(`Cleared pending connection for agent: ${agentId}`);
+		return this.buildActiveSession(response, agentId, connection, params);
+	}
+	/**
+	* Build an ActiveSession from a NewSessionResponse.
+	* Shared by createSession() and retryNewSession().
+	*/
+	buildActiveSession(response, agentId, connection, params) {
 		if (this.provider.registerSession) {
 			this.provider.registerSession(response.sessionId, agentId);
 			this.logger?.debug(`Registered session mapping: ${response.sessionId} → ${agentId}`);
@@ -18880,6 +22400,7 @@ var AgentClient = class {
 		return {
 			list: async (options) => this.sessionManager.listSessions(options),
 			create: async (params) => this.sessionManager.createSession(params),
+			retryNewSession: async (agentId, params) => this.sessionManager.retryNewSession(agentId, params),
 			load: async (params) => {
 				console.log("[AgentClient] sessions.load called:", params.sessionId);
 				return this.sessionManager.loadSession(params);
@@ -20744,6 +24265,28 @@ var BackendProvider = class BackendProvider {
 		if (result?.code === 0 && result?.data) return result.data;
 		throw new Error(result?.msg || "Checkin failed");
 	}
+	/**
+	* 获取专家排行榜数据
+	* API 端点: GET /console/expert/ranking
+	* 完全对齐 getCheckinStatus 的调用方式
+	*/
+	async getExpertRanking() {
+		try {
+			const result = await httpService.get("/console/expert/ranking");
+			if (result?.code === 0 && result?.data) {
+				const normalizedItems = Array.isArray(result.data.items) ? result.data.items : Array.isArray(result.data.experts) ? result.data.experts : [];
+				return {
+					items: normalizedItems,
+					total: result.data.total ?? normalizedItems.length,
+					updateTime: result.data.updateTime ?? Date.now()
+				};
+			}
+			return null;
+		} catch (error) {
+			console.error("[BackendProvider] getExpertRanking failed:", error);
+			return null;
+		}
+	}
 	static {
 		this.SKILLHUB_BASE_URL = "https://lightmake.site";
 	}
@@ -20860,13 +24403,20 @@ const BACKEND_REQUEST_TYPES = {
 	GET_FILE: "backend:get-file",
 	RELOAD_WINDOW: "backend:reload-window",
 	SAVE_LOCALE: "backend:save-locale",
+	SAVE_POWER_BLOCKER: "backend:save-power-blocker",
 	CLOSE_AGENT_MANAGER: "backend:close-agent-manager",
 	OPEN_EXTERNAL: "backend:open-external",
+	OPEN_LOCAL_FILE: "backend:open-local-file",
+	GET_LOCAL_CUSTOM_MODELS: "backend:get-local-custom-models",
+	SAVE_LOCAL_CUSTOM_MODEL: "backend:save-local-custom-model",
+	DELETE_LOCAL_CUSTOM_MODEL: "backend:delete-local-custom-model",
 	BATCH_TOGGLE_PLUGINS: "backend:batch-toggle-plugins",
 	GET_SUPPORT_SCENES: "backend:get-support-scenes",
 	GET_ACCOUNT_USAGE: "backend:get-account-usage",
 	GET_CHECKIN_STATUS: "backend:get-checkin-status",
 	CLAIM_DAILY_CHECKIN: "backend:claim-daily-checkin",
+	GET_ACTIVITY_BANNER: "backend:get-activity-banner",
+	GET_EXPERT_RANKING: "backend:get-expert-ranking",
 	SKILLHUB_LIST: "backend:skillhub-list",
 	SKILLHUB_CATEGORIES: "backend:skillhub-categories",
 	SKILLHUB_SEARCH: "backend:skillhub-search",
@@ -20892,6 +24442,25 @@ var IPCBackendProvider = class {
 		this.debug = config.debug ?? false;
 		this.timeoutMs = config.timeoutMs ?? 3e4;
 		this.log("Initialized with IWidgetChannel");
+		this.setupSessionChangeListener();
+	}
+	/**
+	* 设置会话变化监听器
+	* 监听来自 Extension Host (BackendBridgeService) 推送的 auth:session-changed 事件
+	* 并更新本地 accountService
+	*/
+	setupSessionChangeListener() {
+		this.log("Setting up session change listener");
+		this.channel.on("auth:session-changed", (data) => {
+			this.log("Received auth:session-changed event from Extension Host:", data);
+			const account = data?.account || null;
+			accountService.setAccount(account);
+			this.log("Updated accountService with new session", {
+				hasAccount: !!account,
+				accountNickname: account?.nickname
+			});
+		});
+		this.log("Session change listener setup complete");
 	}
 	/**
 	* 发送统一格式的后端请求
@@ -21170,6 +24739,19 @@ var IPCBackendProvider = class {
 		}
 	}
 	/**
+	* 设置防休眠状态
+	* IDE 环境: 通过 IPC 通知主进程启用/禁用 powerSaveBlocker
+	*/
+	async savePowerBlocker(params) {
+		this.log("Saving power blocker setting via IPC", params);
+		try {
+			await this.sendBackendRequest(BACKEND_REQUEST_TYPES.SAVE_POWER_BLOCKER, params);
+		} catch (error) {
+			this.log("Save power blocker setting failed:", error);
+			throw error;
+		}
+	}
+	/**
 	* 关闭 Agent Manager 面板
 	* IDE 环境: 通过 IPC 通知 IDE 关闭 Agent Manager（用于返回 IDE）
 	*/
@@ -21197,6 +24779,41 @@ var IPCBackendProvider = class {
 		}
 	}
 	/**
+	* 打开本地文件
+	* IDE 环境: 通过 IPC 通知 IDE 打开本地配置文件
+	* @param filePath 要打开的文件路径
+	*/
+	async openLocalFile(filePath) {
+		this.log("Opening local file via IPC:", filePath);
+		try {
+			if (!await this.sendBackendRequest(BACKEND_REQUEST_TYPES.OPEN_LOCAL_FILE, { filePath })) throw new Error(`Failed to open local file: ${filePath}`);
+		} catch (error) {
+			this.log("Open local file request failed:", error);
+			throw error;
+		}
+	}
+	/**
+	* 获取用户级本地自定义模型
+	*/
+	async getLocalCustomModels() {
+		this.log("Getting local custom models via IPC");
+		return await this.sendBackendRequest(BACKEND_REQUEST_TYPES.GET_LOCAL_CUSTOM_MODELS);
+	}
+	/**
+	* 保存用户级本地自定义模型
+	*/
+	async saveLocalCustomModel(request) {
+		this.log("Saving local custom model via IPC:", request);
+		return await this.sendBackendRequest(BACKEND_REQUEST_TYPES.SAVE_LOCAL_CUSTOM_MODEL, request);
+	}
+	/**
+	* 删除用户级本地自定义模型
+	*/
+	async deleteLocalCustomModel(id) {
+		this.log("Deleting local custom model via IPC:", id);
+		return await this.sendBackendRequest(BACKEND_REQUEST_TYPES.DELETE_LOCAL_CUSTOM_MODEL, { id });
+	}
+	/**
 	* 批量切换插件状态
 	* IDE 环境: 通过 IPC 调用 Extension Host 的 PluginService
 	*/
@@ -21275,6 +24892,32 @@ var IPCBackendProvider = class {
 		}
 	}
 	/**
+	* 获取活动 Banner
+	* IDE 环境: 通过 IPC 获取活动 Banner
+	*/
+	async getActivityBanner() {
+		this.log("Getting activity banner via IPC");
+		try {
+			return await this.sendBackendRequest(BACKEND_REQUEST_TYPES.GET_ACTIVITY_BANNER);
+		} catch (error) {
+			this.log("Get activity banner failed:", error);
+			return null;
+		}
+	}
+	/**
+	* 获取专家排行榜数据
+	* IDE 环境: 通过 IPC 获取排行榜数据
+	*/
+	async getExpertRanking() {
+		this.log("Getting expert ranking via IPC");
+		try {
+			return await this.sendBackendRequest(BACKEND_REQUEST_TYPES.GET_EXPERT_RANKING);
+		} catch (error) {
+			this.log("Get expert ranking failed:", error);
+			return null;
+		}
+	}
+	/**
 	* 获取 SkillHub 技能列表
 	* IDE 环境: 通过 IPC 获取技能列表
 	*/
@@ -21420,6 +25063,7 @@ exports.CloudAgentProvider = CloudAgentProvider;
 exports.E2BFilesystem = require_e2b_filesystem.E2BFilesystem;
 exports.HttpService = HttpService;
 exports.IPCBackendProvider = IPCBackendProvider;
+exports.SessionError = SessionError;
 exports.SessionManager = SessionManager;
 exports.__toESM = __toESM;
 exports.createBackendProvider = createBackendProvider;