666 lines
25 KiB
Rust
666 lines
25 KiB
Rust
//! # ACP Session Manager
|
||
//!
|
||
//! 基于 project_id 管理 ACP 会话的核心模块。
|
||
//!
|
||
//! ## SACP 迁移说明
|
||
//!
|
||
//! 本模块已迁移至 SACP 实现：
|
||
//! - 移除了 `Client` trait 泛型参数（SACP 内部处理）
|
||
//! - 简化了 `create_session` 参数（不再需要 client 和 shared_api_key_manager）
|
||
//! - 使用标准 tokio::spawn（无需 LocalSet）
|
||
//!
|
||
//! ## 职责范围
|
||
//!
|
||
//! 1. **会话生命周期管理**
|
||
//! - 创建新会话 (`create_session`)
|
||
//! - 获取或复用会话 (`get_or_create_session`)
|
||
//! - 移除会话 (`remove_session`)
|
||
//! - 检测会话健康状态（channel 是否关闭）
|
||
//!
|
||
//! 2. **Prompt 构建**
|
||
//! - 构建纯文本 Prompt (`build_text_prompt_request`)
|
||
//! - 构建带附件的 Prompt (`build_prompt_request_with_attachments`)
|
||
//! - 将 request_id 放入 meta 字段
|
||
//!
|
||
//! 3. **路径处理**
|
||
//! - 路径规范化 (`normalize_path`)
|
||
//! - 确保项目目录存在 (`ensure_project_dir`)
|
||
//!
|
||
//! ## 架构说明
|
||
//!
|
||
//! 使用依赖注入的 `SessionRegistry` 进行会话存储：
|
||
//! - 统一使用注入的 `SessionRegistry`（通常是 `AGENT_REGISTRY`）
|
||
//!
|
||
//! ## 与 Worker 的协作
|
||
//!
|
||
//! ```text
|
||
//! AcpAgentWorker (acp_worker.rs)
|
||
//! │
|
||
//! │ 1. 调用 get_or_create_session()
|
||
//! ▼
|
||
//! AcpSessionManager
|
||
//! │
|
||
//! │ 2. 通过 SessionRegistry 获取/创建会话
|
||
//! │ 3. 通过 SacpClaudeCodeLauncher 启动 Agent
|
||
//! ▼
|
||
//! SessionRegistry (注入的 AGENT_REGISTRY)
|
||
//! ```
|
||
|
||
use std::path::{Component, PathBuf};
|
||
use std::sync::Arc;
|
||
|
||
use agent_config::PromptBuilder;
|
||
use anyhow::Result;
|
||
use chrono::Utc;
|
||
use agent_client_protocol::schema::{ContentBlock, PromptRequest, SessionId, TextContent};
|
||
use shared_types::{
|
||
AgentLifecycle, AgentStatus, ModelProviderConfig, ProjectAndAgentInfo, SessionEntry,
|
||
};
|
||
use tracing::{debug, error, info};
|
||
|
||
use crate::PromptMessage;
|
||
use crate::launcher::ClaudeCodeLauncher;
|
||
use crate::traits::{AgentStartConfig, SessionNotifier, SessionRegistry};
|
||
|
||
/// ACP 会话管理器 (SACP 版本)
|
||
///
|
||
/// 管理所有活跃的 ACP 会话，提供：
|
||
/// - 会话创建和复用
|
||
/// - 模型配置变化检测
|
||
/// - 会话生命周期管理
|
||
///
|
||
/// ## 泛型参数
|
||
/// - `N`: SessionNotifier 实现，用于推送 SSE 消息
|
||
/// - `R`: SessionRegistry 实现，用于存储会话数据（通常是 AGENT_REGISTRY）
|
||
pub struct AcpSessionManager<N: SessionNotifier, R: SessionRegistry> {
|
||
/// 会话注册表（注入的 SessionRegistry）
|
||
registry: Arc<R>,
|
||
/// 会话通知器
|
||
notifier: Arc<N>,
|
||
}
|
||
|
||
impl<N: SessionNotifier + 'static, R: SessionRegistry> AcpSessionManager<N, R>
|
||
where
|
||
R::Entry: Into<ProjectAndAgentInfo> + From<ProjectAndAgentInfo>,
|
||
{
|
||
/// 创建新的会话管理器
|
||
///
|
||
/// # 参数
|
||
/// - `notifier`: 会话通知器
|
||
/// - `registry`: 会话注册表（通常注入 AGENT_REGISTRY）
|
||
pub fn new(notifier: Arc<N>, registry: Arc<R>) -> Self {
|
||
Self { registry, notifier }
|
||
}
|
||
|
||
/// 获取会话信息
|
||
pub fn get_session(&self, project_id: &str) -> Option<R::Entry> {
|
||
self.registry.get(project_id)
|
||
}
|
||
|
||
/// 检查会话是否存在
|
||
pub fn contains_session(&self, project_id: &str) -> bool {
|
||
self.registry.contains(project_id)
|
||
}
|
||
|
||
/// 移除会话
|
||
pub fn remove_session(&self, project_id: &str) -> Option<R::Entry> {
|
||
self.registry.remove(project_id)
|
||
}
|
||
|
||
/// 获取所有会话的 project_id 列表
|
||
pub fn list_sessions(&self) -> Vec<String> {
|
||
self.registry.list_project_ids()
|
||
}
|
||
|
||
/// 获取会话数量
|
||
pub fn session_count(&self) -> usize {
|
||
self.registry.count()
|
||
}
|
||
|
||
/// 获取 registry 的 Arc 引用
|
||
pub fn registry(&self) -> Arc<R> {
|
||
self.registry.clone()
|
||
}
|
||
|
||
/// 获取 notifier 的 Arc 引用
|
||
pub fn notifier(&self) -> Arc<N> {
|
||
self.notifier.clone()
|
||
}
|
||
|
||
/// 规范化项目路径
|
||
///
|
||
/// - 如果是相对路径，先与当前目录拼接
|
||
/// - 去除路径中的 "./"（CurDir 组件）
|
||
pub fn normalize_path(path: &PathBuf) -> PathBuf {
|
||
let joined_path = if path.is_absolute() {
|
||
path.clone()
|
||
} else {
|
||
std::env::current_dir().unwrap_or_default().join(path)
|
||
};
|
||
|
||
joined_path
|
||
.components()
|
||
.filter(|c| !matches!(c, Component::CurDir))
|
||
.collect()
|
||
}
|
||
|
||
/// 确保项目目录存在
|
||
pub async fn ensure_project_dir(path: &PathBuf) -> Result<()> {
|
||
if !path.exists() {
|
||
info!("Project path does not exist, creating: {:?}", path);
|
||
tokio::fs::create_dir_all(path).await?;
|
||
}
|
||
Ok(())
|
||
}
|
||
|
||
/// 构建基础 Prompt 请求（仅文本内容）
|
||
///
|
||
/// 使用 ACP 协议分离模式：
|
||
/// - 系统提示词已在 NewSessionRequest._meta.systemPrompt 中传递
|
||
/// - 这里只构建纯用户提示词
|
||
///
|
||
/// 注意：附件转换由调用方处理（因为涉及文件 I/O）
|
||
pub fn build_text_prompt_request(
|
||
prompt: &PromptMessage,
|
||
session_id: SessionId,
|
||
) -> Result<PromptRequest> {
|
||
// 构建纯用户提示词
|
||
let final_prompt = if prompt.data_source_attachments.is_empty() {
|
||
PromptBuilder::build_user_prompt(&prompt.content)
|
||
} else {
|
||
PromptBuilder::build_user_prompt_with_data_sources(
|
||
&prompt.content,
|
||
&prompt.data_source_attachments,
|
||
)
|
||
};
|
||
|
||
// 创建文本内容块
|
||
let text_block = ContentBlock::Text(TextContent::new(final_prompt));
|
||
let content_blocks = vec![text_block];
|
||
|
||
// 将 request_id 放入 meta 字段
|
||
debug!(
|
||
"🔧 [build_prompt] Putting request_id={} into PromptRequest.meta",
|
||
prompt.request_id
|
||
);
|
||
let mut meta = serde_json::Map::new();
|
||
meta.insert(
|
||
"request_id".to_string(),
|
||
serde_json::Value::String(prompt.request_id.clone()),
|
||
);
|
||
|
||
Ok(PromptRequest::new(session_id, content_blocks).meta(meta))
|
||
}
|
||
|
||
/// 构建带附件的 Prompt 请求
|
||
///
|
||
/// # Arguments
|
||
/// * `prompt` - 提示消息
|
||
/// * `session_id` - 会话 ID
|
||
/// * `attachment_blocks` - 已转换的附件内容块
|
||
pub fn build_prompt_request_with_attachments(
|
||
prompt: &PromptMessage,
|
||
session_id: SessionId,
|
||
attachment_blocks: Vec<ContentBlock>,
|
||
) -> Result<PromptRequest> {
|
||
// 构建纯用户提示词
|
||
let final_prompt = if prompt.data_source_attachments.is_empty() {
|
||
PromptBuilder::build_user_prompt(&prompt.content)
|
||
} else {
|
||
PromptBuilder::build_user_prompt_with_data_sources(
|
||
&prompt.content,
|
||
&prompt.data_source_attachments,
|
||
)
|
||
};
|
||
|
||
// 创建文本内容块
|
||
let text_block = ContentBlock::Text(TextContent::new(final_prompt));
|
||
let mut content_blocks = vec![text_block];
|
||
|
||
// 添加附件内容块
|
||
content_blocks.extend(attachment_blocks);
|
||
|
||
// 将 request_id 放入 meta 字段
|
||
debug!(
|
||
"🔧 [build_prompt] Putting request_id={} into PromptRequest.meta",
|
||
prompt.request_id
|
||
);
|
||
let mut meta = serde_json::Map::new();
|
||
meta.insert(
|
||
"request_id".to_string(),
|
||
serde_json::Value::String(prompt.request_id.clone()),
|
||
);
|
||
|
||
Ok(PromptRequest::new(session_id, content_blocks).meta(meta))
|
||
}
|
||
|
||
/// 创建新的 Agent 会话 (SACP 版本)
|
||
///
|
||
/// 启动 Agent 进程并建立 SACP 连接
|
||
///
|
||
/// # 参数
|
||
/// - `project_id`: 项目 ID
|
||
/// - `project_path`: 项目路径
|
||
/// - `model_provider`: 模型提供者配置
|
||
/// - `start_config`: Agent 启动配置
|
||
/// - `service_uuid`: 与此 Agent 关联的唯一 UUID
|
||
///
|
||
/// # 返回值
|
||
/// - `R::Entry`: 会话条目
|
||
pub async fn create_session(
|
||
&self,
|
||
project_id: String,
|
||
project_path: PathBuf,
|
||
_session_id_hint: Option<String>,
|
||
model_provider: Option<ModelProviderConfig>,
|
||
start_config: AgentStartConfig,
|
||
service_uuid: Option<String>,
|
||
) -> Result<R::Entry> {
|
||
let agent_info = self
|
||
.create_session_internal(
|
||
project_id.clone(),
|
||
project_path,
|
||
model_provider,
|
||
start_config,
|
||
service_uuid,
|
||
)
|
||
.await?;
|
||
|
||
// 存储会话信息到 registry
|
||
let session_id_str = agent_info.session_id().to_string();
|
||
self.registry
|
||
.insert(&project_id, &session_id_str, agent_info.clone());
|
||
|
||
Ok(agent_info)
|
||
}
|
||
|
||
/// 内部方法：创建 Agent 会话但不插入到 registry
|
||
///
|
||
/// 用于 entry API 优化，避免重复插入
|
||
async fn create_session_internal(
|
||
&self,
|
||
project_id: String,
|
||
project_path: PathBuf,
|
||
model_provider: Option<ModelProviderConfig>,
|
||
start_config: AgentStartConfig,
|
||
service_uuid: Option<String>,
|
||
) -> Result<R::Entry> {
|
||
info!(
|
||
"Creating Agent session, project ID: {}",
|
||
project_id
|
||
);
|
||
|
||
// 创建 SACP 启动器
|
||
let launcher = ClaudeCodeLauncher::new(self.notifier.clone());
|
||
|
||
// 记录是否使用了 resume（仅用于日志）
|
||
let has_resume = start_config.resume_session_id.is_some();
|
||
if has_resume {
|
||
info!(
|
||
"📌 Starting Agent with resume: session_id={:?}",
|
||
start_config.resume_session_id
|
||
);
|
||
}
|
||
|
||
// 启动 Agent (SACP 版本)
|
||
// 如果 resume 失败，直接返回错误，让上层（rcoder）决定是否降级重试
|
||
let connection_info = launcher
|
||
.launch(
|
||
project_id.clone(),
|
||
project_path.clone(),
|
||
model_provider.clone(),
|
||
start_config.clone(),
|
||
self.registry.clone(),
|
||
service_uuid,
|
||
)
|
||
.await?;
|
||
|
||
info!(
|
||
"✅ Agent session created successfully, session ID: {}",
|
||
connection_info.session_id
|
||
);
|
||
|
||
// 创建 ProjectAndAgentInfo
|
||
let lifecycle_handle =
|
||
Some(connection_info.lifecycle_guard.clone() as Arc<dyn AgentLifecycle>);
|
||
let now = Utc::now();
|
||
let agent_info = ProjectAndAgentInfo {
|
||
project_id: project_id.clone(),
|
||
session_id: connection_info.session_id.clone(),
|
||
prompt_tx: connection_info.prompt_tx,
|
||
cancel_tx: connection_info.cancel_tx,
|
||
model_provider: model_provider.clone(),
|
||
request_id: None,
|
||
status: AgentStatus::Idle,
|
||
last_activity: now,
|
||
created_at: now,
|
||
stop_handle: lifecycle_handle,
|
||
};
|
||
|
||
// 返回 agent_info（不插入 registry，由调用方处理）
|
||
Ok(agent_info.into())
|
||
}
|
||
|
||
/// 获取或创建会话 (SACP 版本)
|
||
///
|
||
/// 如果会话已存在且模型配置未变化，则复用；否则创建新会话
|
||
///
|
||
/// # 优化说明
|
||
/// 获取或创建会话
|
||
///
|
||
/// # 参数
|
||
/// - `project_id`: 项目 ID
|
||
/// - `project_path`: 项目路径
|
||
/// - `session_id_hint`: 会话 ID 提示（用于恢复现有会话）
|
||
/// - `model_provider`: 模型提供者配置
|
||
/// - `start_config`: Agent 启动配置
|
||
/// - `service_uuid`: 与此 Agent 关联的唯一 UUID
|
||
///
|
||
/// # 返回值
|
||
/// - `R::Entry`: 会话条目
|
||
/// - `bool`: 是否是新创建的会话
|
||
///
|
||
/// # 并发安全性
|
||
///
|
||
/// 使用"检查-创建-插入"三阶段模式避免在持有 entry 期间调用 `.await`：
|
||
///
|
||
/// 1. **快速检查**：检查会话是否已存在且有效
|
||
/// 2. **创建会话**：如果需要创建，在**不持有锁**的情况下创建会话（.await）
|
||
/// 3. **原子性插入**：使用 entry API 原子性插入，如果其他线程已创建则使用已存在的
|
||
///
|
||
/// 这样确保：
|
||
/// - 不会在持有 DashMap entry 期间跨越 await 点
|
||
/// - 同一 project_id 最多只会创建一个会话
|
||
/// - 高并发下不会阻塞其他 project_id 的访问（DashMap 分段锁特性）
|
||
pub async fn get_or_create_session(
|
||
&self,
|
||
project_id: &str,
|
||
project_path: PathBuf,
|
||
session_id_hint: Option<String>, // 🔥 修复：使用此参数查找现有会话
|
||
model_provider: Option<ModelProviderConfig>,
|
||
start_config: AgentStartConfig,
|
||
service_uuid: Option<String>,
|
||
) -> Result<(R::Entry, bool)> {
|
||
use dashmap::mapref::entry::Entry;
|
||
|
||
let project_id_key = project_id.to_string();
|
||
|
||
// 🆕 第一阶段：如果提供了 session_id_hint，先尝试通过 session_id 查找现有会话
|
||
// 🔥 优化：使用 get_entry_by_session() 避免两次调用之间的竞态窗口
|
||
if let Some(ref hint_sid) = session_id_hint {
|
||
// 一次性查询：通过 session_id 直接获取 agent_info
|
||
if let Some(existing) = self.registry.get_entry_by_session(hint_sid) {
|
||
// 验证 project_id 是否匹配（防御性编程）
|
||
if existing.project_id() == project_id {
|
||
let channel_closed = existing.is_channel_closed();
|
||
let model_changed = existing.is_model_config_changed(&model_provider);
|
||
|
||
if !channel_closed && !model_changed {
|
||
info!(
|
||
"[SESSION] Reusing existing session via session_id_hint: project_id={}, session_id={}",
|
||
project_id, hint_sid
|
||
);
|
||
return Ok((existing, false));
|
||
}
|
||
|
||
if channel_closed {
|
||
info!(
|
||
"⚠️ [SESSION] Session channel closed for session_id_hint, need to rebuild: project_id={}, session_id={}",
|
||
project_id, hint_sid
|
||
);
|
||
}
|
||
if model_changed {
|
||
info!(
|
||
"🔄 [SESSION] Model config changed for session_id_hint, need to rebuild: project_id={}, session_id={}",
|
||
project_id, hint_sid
|
||
);
|
||
}
|
||
// 会话无效，继续后续逻辑（可能需要重建）
|
||
} else {
|
||
info!(
|
||
"⚠️ [SESSION] session_id_hint belongs to different project: hint_project={}, current_project={}, session_id={}",
|
||
existing.project_id(),
|
||
project_id,
|
||
hint_sid
|
||
);
|
||
// session_id 属于其他 project，不能复用，继续后续逻辑
|
||
}
|
||
} else {
|
||
info!(
|
||
"🔍 [SESSION] session_id_hint does not exist in registry: session_id={}",
|
||
hint_sid
|
||
);
|
||
// session_id 不存在，继续后续逻辑
|
||
}
|
||
}
|
||
|
||
// 第一阶段：快速检查现有会话
|
||
if let Entry::Occupied(occupied_entry) = self.registry.entry(project_id_key.clone()) {
|
||
let existing = occupied_entry.get();
|
||
|
||
// 🔥 显式检查 Pending 状态 - PendingGuard 创建的占位符需要被替换
|
||
if *existing.status() == AgentStatus::Pending {
|
||
info!(
|
||
"🔄 [SESSION] Detected Pending placeholder, preparing to replace: project_id={}",
|
||
project_id
|
||
);
|
||
// 显式释放 entry 锁
|
||
drop(occupied_entry);
|
||
|
||
// 第二阶段：创建新会话（不持有锁）
|
||
let new_session = self
|
||
.create_session_internal(
|
||
project_id_key.clone(),
|
||
project_path,
|
||
model_provider,
|
||
start_config,
|
||
service_uuid,
|
||
)
|
||
.await?;
|
||
|
||
// 第三阶段：原子性替换（插入新会话，覆盖 pending 占位符）
|
||
match self.registry.entry(project_id_key.clone()) {
|
||
Entry::Vacant(entry) => {
|
||
let new_session_id = new_session.session_id().to_string();
|
||
entry.insert(new_session.clone());
|
||
info!(
|
||
"✅ [SESSION] Inserted new session to replace pending: project_id={}, session_id={}",
|
||
project_id, new_session_id
|
||
);
|
||
return Ok((new_session, true));
|
||
}
|
||
Entry::Occupied(mut entry) => {
|
||
// 检查是 Pending 占位符还是其他线程创建的真实会话
|
||
let current_session = entry.get();
|
||
let current_status = current_session.status();
|
||
|
||
if *current_status == AgentStatus::Pending {
|
||
// 仍然是 Pending 占位符，替换它
|
||
let old_session_id = current_session.session_id().to_string();
|
||
let new_session_id = new_session.session_id().to_string();
|
||
entry.insert(new_session.clone());
|
||
info!(
|
||
"✅ [SESSION] Replaced pending placeholder: project_id={}, {} → {}",
|
||
project_id, old_session_id, new_session_id
|
||
);
|
||
return Ok((new_session, true));
|
||
} else {
|
||
// 其他线程已经创建了真实会话，使用已存在的（丢弃我们创建的）
|
||
let existing_session = current_session.clone();
|
||
let created_session_id = new_session.session_id().to_string();
|
||
let existing_session_id = existing_session.session_id().to_string();
|
||
info!(
|
||
"🔄 [SESSION] Detected concurrent creation (other thread already created real session): project_id={}, discarded session_id={}, using session_id={}",
|
||
project_id, created_session_id, existing_session_id
|
||
);
|
||
// new_session 会被 drop，AgentLifecycleGuard 会清理 Agent 进程
|
||
return Ok((existing_session, false));
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
let channel_closed = existing.is_channel_closed();
|
||
let model_changed = existing.is_model_config_changed(&model_provider);
|
||
|
||
if !channel_closed && !model_changed {
|
||
info!("Reuse Agent session, project ID: {}", project_id);
|
||
return Ok((existing.clone(), false));
|
||
}
|
||
|
||
// 需要重建会话，先克隆必要数据并释放锁
|
||
let session_id_str = existing.session_id().to_string();
|
||
drop(occupied_entry); // 显式释放 entry 锁
|
||
|
||
if channel_closed {
|
||
info!(
|
||
"⚠️ Detected session channel closed (Agent process exited), rebuilding session, project ID: {}, old session_id: {}",
|
||
project_id, session_id_str
|
||
);
|
||
}
|
||
if model_changed {
|
||
info!(
|
||
"Model config changed, restarting Agent session, project ID: {}, old session_id: {}",
|
||
project_id, session_id_str
|
||
);
|
||
}
|
||
|
||
// 第二阶段：在不持有锁的情况下创建新会话
|
||
let new_session = self
|
||
.create_session_internal(
|
||
project_id_key.clone(),
|
||
project_path,
|
||
model_provider,
|
||
start_config,
|
||
service_uuid,
|
||
)
|
||
.await?;
|
||
|
||
// 第三阶段：原子性插入（使用 entry API 防止并发创建）
|
||
match self.registry.entry(project_id_key.clone()) {
|
||
Entry::Vacant(entry) => {
|
||
// 其他线程还没有创建，使用我们创建的会话
|
||
let new_session_id = new_session.session_id().to_string();
|
||
entry.insert(new_session.clone());
|
||
info!(
|
||
"✅ Session rebuilt, project ID: {}, new session_id: {}",
|
||
project_id, new_session_id
|
||
);
|
||
return Ok((new_session, true));
|
||
}
|
||
Entry::Occupied(entry) => {
|
||
// 其他线程已经创建了会话，使用已存在的（丢弃我们创建的）
|
||
let existing_session = entry.get().clone();
|
||
let created_session_id = new_session.session_id().to_string();
|
||
let existing_session_id = existing_session.session_id().to_string();
|
||
info!(
|
||
"🔄 [SESSION] Detected concurrent creation, using other thread's session: project_id={}, discarded session_id={}, using session_id={}",
|
||
project_id, created_session_id, existing_session_id
|
||
);
|
||
// new_session 会被 drop，Session 的 Drop 实现会清理 Agent 进程
|
||
return Ok((existing_session, false));
|
||
}
|
||
}
|
||
}
|
||
|
||
// 会话不存在，需要创建新会话
|
||
info!(
|
||
"Session not found, creating new session, project ID: {}",
|
||
project_id
|
||
);
|
||
|
||
// 第二阶段：在不持有锁的情况下创建新会话
|
||
let new_session = self
|
||
.create_session_internal(
|
||
project_id_key.clone(),
|
||
project_path,
|
||
model_provider,
|
||
start_config,
|
||
service_uuid,
|
||
)
|
||
.await?;
|
||
|
||
// 第三阶段：原子性插入
|
||
match self.registry.entry(project_id_key.clone()) {
|
||
Entry::Vacant(entry) => {
|
||
// 其他线程还没有创建，使用我们创建的会话
|
||
let session_id_str = new_session.session_id().to_string();
|
||
entry.insert(new_session.clone());
|
||
info!(
|
||
"✅ New session created, project ID: {}, session_id: {}",
|
||
project_id, session_id_str
|
||
);
|
||
Ok((new_session, true))
|
||
}
|
||
Entry::Occupied(entry) => {
|
||
// 其他线程已经创建了会话，使用已存在的（丢弃我们创建的）
|
||
let existing_session = entry.get().clone();
|
||
let created_session_id = new_session.session_id().to_string();
|
||
let existing_session_id = existing_session.session_id().to_string();
|
||
info!(
|
||
"🔄 [SESSION] Detected concurrent creation, using session created by other thread: project_id={}, discarding session_id={}, using session_id={}",
|
||
project_id, created_session_id, existing_session_id
|
||
);
|
||
// new_session 会被 drop，Session 的 Drop 实现会清理 Agent 进程
|
||
Ok((existing_session, false))
|
||
}
|
||
}
|
||
}
|
||
|
||
/// 发送 Prompt 到指定会话（仅文本）
|
||
///
|
||
/// 使用有界通道，提供背压保护。如果通道已满，会异步等待直到有空间。
|
||
pub async fn send_text_prompt(&self, project_id: &str, prompt: &PromptMessage) -> Result<()> {
|
||
let session = self
|
||
.get_session(project_id)
|
||
.ok_or_else(|| anyhow::anyhow!("Session not found: {}", project_id))?;
|
||
|
||
let prompt_request = Self::build_text_prompt_request(prompt, session.session_id().clone())?;
|
||
|
||
session
|
||
.prompt_tx()
|
||
.send(prompt_request)
|
||
.await
|
||
.map_err(|e| {
|
||
error!("send Prompt requestfailed: {:?}", e);
|
||
anyhow::anyhow!("Failed to send Prompt request: {:?}", e)
|
||
})?;
|
||
|
||
info!("Prompt request already sent, project ID: {}", project_id);
|
||
Ok(())
|
||
}
|
||
|
||
/// 发送 Prompt 请求到指定会话
|
||
///
|
||
/// 使用有界通道，提供背压保护。如果通道已满，会异步等待直到有空间。
|
||
pub async fn send_prompt_request(
|
||
&self,
|
||
project_id: &str,
|
||
prompt_request: PromptRequest,
|
||
) -> Result<()> {
|
||
let session = self
|
||
.get_session(project_id)
|
||
.ok_or_else(|| anyhow::anyhow!("Session not found: {}", project_id))?;
|
||
|
||
session
|
||
.prompt_tx()
|
||
.send(prompt_request)
|
||
.await
|
||
.map_err(|e| {
|
||
error!("send Prompt requestfailed: {:?}", e);
|
||
anyhow::anyhow!("Failed to send Prompt request: {:?}", e)
|
||
})?;
|
||
|
||
info!("Prompt request already sent, project ID: {}", project_id);
|
||
Ok(())
|
||
}
|
||
}
|
||
|
||
impl<N: SessionNotifier + 'static, R: SessionRegistry> std::fmt::Debug for AcpSessionManager<N, R> {
|
||
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
||
f.debug_struct("AcpSessionManager")
|
||
.field("session_count", &self.registry.count())
|
||
.finish()
|
||
}
|
||
}
|