添加qiming-rcoder模块

qiming-rcoder/crates/rcoder/src/grpc/chat_client.rs

@@ -0,0 +1,198 @@
+//! gRPC Chat 客户端
+//!
+//! 通过 gRPC 调用 agent_runner 的 Chat RPC
+
+use crate::grpc::GrpcChannelPool;
+use shared_types::ChatAgentConfig;
+use shared_types::grpc::{
+    CancelRequest, CancelResponse, ChatRequest as GrpcChatRequest, ChatResponse as GrpcChatResponse,
+};
+use std::sync::Arc;
+use tracing::{debug, error, info};
+
+/// 通过 gRPC 发送 Chat 请求到 agent_runner (使用连接池)
+pub async fn grpc_chat_with_pool(
+    pool: &Arc<GrpcChannelPool>,
+    grpc_addr: &str,
+    project_id: String,
+    session_id: Option<String>,
+    prompt: String,
+    attachments: Vec<shared_types::Attachment>,
+    data_source_attachments: Vec<String>,
+    model_config: Option<shared_types::ModelProviderConfig>,
+    request_id: Option<String>,
+    request_timeout: Option<std::time::Duration>,
+    // 新增参数 (v2)
+    system_prompt: Option<String>,
+    user_prompt: Option<String>,
+    agent_config: Option<ChatAgentConfig>,
+    service_type: Option<shared_types::ServiceType>,
+    user_id: Option<String>, // 新增：用于 ComputerAgentRunner 模式
+) -> anyhow::Result<GrpcChatResponse> {
+    info!(
+        "🚀 [gRPC_CHAT] Sending Chat request (connection pool): addr={}, project_id={}",
+        grpc_addr, project_id
+    );
+
+    // 使用连接池获取客户端
+    let mut client = pool.get_client(grpc_addr).await?;
+
+    // 构建 gRPC 请求
+    let grpc_request = GrpcChatRequest {
+        project_id,
+        session_id: session_id.unwrap_or_default(),
+        prompt,
+        model_config: model_config.map(super::converters::to_grpc_model_config),
+        attachments: attachments
+            .into_iter()
+            .map(super::converters::to_grpc_attachment)
+            .collect(),
+        request_id,
+        data_source_attachments,
+        // 新增字段 (v2)
+        system_prompt,
+        user_prompt,
+        agent_config: agent_config.map(super::converters::to_grpc_chat_agent_config),
+        service_type: service_type.map(|st| format!("{:?}", st)),
+        user_id, // 传递 user_id
+    };
+
+    debug!("[gRPC_CHAT] sendrequest: {:?}", grpc_request);
+
+    // 构建 tonic Request 并设置请求级别超时
+    let locale = super::current_grpc_locale();
+    let mut request = super::new_request_with_locale(grpc_request, locale);
+
+    // ✅ 使用 Tonic 原生 API 设置请求超时
+    if let Some(timeout) = request_timeout {
+        request.set_timeout(timeout);
+        debug!("⏱️ [gRPC_CHAT] request timeout: {:?}", timeout);
+    }
+
+    // 发送请求
+    let response = client.chat(request).await.map_err(|e| {
+        error!("[gRPC_CHAT] Chat RPC call failed: {}", e);
+        anyhow::anyhow!("gRPC Chat call failed: {}", e)
+    })?;
+
+    let chat_response = response.into_inner();
+
+    info!(
+        "✅ [gRPC_CHAT] Received response: project_id={}, session_id={}, success={}",
+        chat_response.project_id, chat_response.session_id, chat_response.success
+    );
+
+    Ok(chat_response)
+}
+
+/// 将 gRPC ChatResponse 转换为内部 ChatResponse
+pub fn grpc_response_to_chat_response(grpc_resp: GrpcChatResponse) -> shared_types::ChatResponse {
+    shared_types::ChatResponse {
+        project_id: grpc_resp.project_id,
+        session_id: grpc_resp.session_id,
+        error: grpc_resp.error,
+        request_id: grpc_resp.request_id,
+        need_fallback: None,
+        fallback_reason: None,
+    }
+}
+
+/// 通过 gRPC 取消会话（使用连接池）
+pub async fn grpc_cancel_session_with_pool(
+    pool: &Arc<GrpcChannelPool>,
+    grpc_addr: &str,
+    session_id: String,
+    reason: String,
+    project_id: String,
+) -> anyhow::Result<CancelResponse> {
+    info!(
+        "🛑 [gRPC_CANCEL] Sending cancel session request (connection pool): addr={}, session_id={}, project_id={}",
+        grpc_addr, session_id, project_id
+    );
+
+    // 使用连接池获取客户端
+    let mut client = pool.get_client(grpc_addr).await?;
+
+    // 构建 gRPC 请求
+    let grpc_request = CancelRequest {
+        session_id,
+        reason,
+        project_id,
+    };
+
+    debug!("[gRPC_CANCEL] sendrequest: {:?}", grpc_request);
+
+    // 发送请求
+    let locale = super::current_grpc_locale();
+    let request = super::new_request_with_locale(grpc_request, locale);
+
+    let response = client.cancel_session(request).await.map_err(|e| {
+        error!("[gRPC_CANCEL] CancelSession RPC call failed: {}", e);
+        anyhow::anyhow!("gRPC CancelSession call failed: {}", e)
+    })?;
+
+    let cancel_response = response.into_inner();
+
+    info!(
+        "✅ [gRPC_CANCEL] Received response: success={}, message={:?}",
+        cancel_response.success, cancel_response.message
+    );
+
+    Ok(cancel_response)
+}
+
+/// 通过 gRPC 取消会话（不使用连接池，兼容旧接口）
+pub async fn grpc_cancel_session(
+    grpc_addr: &str,
+    session_id: String,
+    reason: String,
+    project_id: String,
+) -> anyhow::Result<CancelResponse> {
+    // 创建临时连接池（单次使用）
+    let pool = Arc::new(GrpcChannelPool::new());
+    grpc_cancel_session_with_pool(&pool, grpc_addr, session_id, reason, project_id).await
+}
+
+/// 通过 gRPC 停止 Agent（使用连接池）
+pub async fn grpc_stop_agent_with_pool(
+    pool: &Arc<GrpcChannelPool>,
+    grpc_addr: &str,
+    project_id: String,
+    reason: Option<String>,
+    force: bool,
+) -> anyhow::Result<shared_types::grpc::StopAgentResponse> {
+    info!(
+        "🔄 [gRPC_STOP_AGENT] Sending stop Agent request (connection pool): addr={}, project_id={}, force={}",
+        grpc_addr, project_id, force
+    );
+
+    // 使用连接池获取客户端
+    let mut client = pool.get_client(grpc_addr).await?;
+
+    // 构建 gRPC 请求
+    let grpc_request = shared_types::grpc::StopAgentRequest {
+        project_id: project_id.clone(),
+        reason,
+        force,
+    };
+
+    debug!("[gRPC_STOP_AGENT] sendrequest: {:?}", grpc_request);
+
+    // 发送请求
+    let locale = super::current_grpc_locale();
+    let request = super::new_request_with_locale(grpc_request, locale);
+
+    let response = client.stop_agent(request).await.map_err(|e| {
+        error!("[gRPC_STOP_AGENT] StopAgent RPC call failed: {}", e);
+        anyhow::anyhow!("gRPC StopAgent call failed: {}", e)
+    })?;
+
+    let stop_response = response.into_inner();
+
+    info!(
+        "✅ [gRPC_STOP_AGENT] Received response: result={}, success={}, message={:?}",
+        stop_response.result, stop_response.success, stop_response.message
+    );
+
+    Ok(stop_response)
+}