158 lines
5.6 KiB
Rust
158 lines
5.6 KiB
Rust
//! TUI agent turn interface adapter — resolves LLM provider configuration,
|
|
//! builds the tool context, and spawns the agent turn on a background task.
|
|
|
|
use std::sync::atomic::Ordering;
|
|
use tracing::info;
|
|
|
|
use zesdex_domain::core::ChatMessage;
|
|
use zesdex_domain::agent::AgentTurnParams;
|
|
use zesdex_infrastructure::llm::provider::LlmClient;
|
|
use zesdex_infrastructure::tools::executor::InfrastructureToolExecutor;
|
|
use zesdex_infrastructure::tools::{all_tools, tool_defs, ToolCtx};
|
|
use zesdex_application::agent::turn_service::AgentTurnServiceImpl;
|
|
use zesdex_application::agent::AgentTurnService;
|
|
|
|
use crate::state::AppStateRest;
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Provider resolution
|
|
// ---------------------------------------------------------------------------
|
|
|
|
/// Resolve the API key from settings or environment for the given provider.
|
|
fn resolve_api_key(state: &AppStateRest, provider_name: &str) -> String {
|
|
if let Some(key) = state.settings.api_keys.get(provider_name) {
|
|
return key.clone();
|
|
}
|
|
if let Some(ref cfg) = state.app_config.providers.get(provider_name) {
|
|
if let Some(ref default_key) = cfg.default_api_key {
|
|
if !default_key.is_empty() {
|
|
return default_key.clone();
|
|
}
|
|
}
|
|
if let Some(ref env_name) = cfg.api_key_env {
|
|
if let Ok(val) = std::env::var(env_name) {
|
|
return val;
|
|
}
|
|
}
|
|
}
|
|
String::new()
|
|
}
|
|
|
|
/// Resolve the API base URL from the provider config.
|
|
fn resolve_api_base(state: &AppStateRest, provider_name: &str) -> Option<String> {
|
|
state
|
|
.app_config
|
|
.providers
|
|
.get(provider_name)
|
|
.map(|cfg| cfg.api_base.clone())
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Turn spawning
|
|
// ---------------------------------------------------------------------------
|
|
|
|
/// Spawn an agent turn on a background Tokio task.
|
|
///
|
|
/// Flow:
|
|
/// 1. Compare-exchange the in-flight flag (no-op if already running).
|
|
/// 2. Resolve provider (API key, model, base URL) from settings.
|
|
/// 3. Build messages including the user's input text.
|
|
/// 4. Construct `AgentTurnParams` with the turn-event queue and abort flag.
|
|
/// 5. Create `LlmClient`, `ToolCtx`, and `InfrastructureToolExecutor`.
|
|
/// 6. Assemble `AgentTurnServiceImpl` and spawn it via `tokio::spawn`.
|
|
#[tracing::instrument(skip(state))]
|
|
pub fn spawn_agent_turn(state: &mut AppStateRest, text: String) {
|
|
// Only one turn at a time — compare_exchange is lock-free
|
|
if state
|
|
.turn_in_flight_flag
|
|
.compare_exchange(false, true, Ordering::SeqCst, Ordering::Relaxed)
|
|
.is_err()
|
|
{
|
|
return;
|
|
}
|
|
|
|
let turn_events = state.turn_events.clone();
|
|
let in_flight = state.turn_in_flight_flag.clone();
|
|
let abort = state.abort_flag.clone();
|
|
let session_dir = state.session_dir.clone();
|
|
let workspace_roots = state.workspace_roots.clone();
|
|
|
|
// ── Resolve provider configuration ─────────────────────────────────
|
|
let provider_name = &state.settings.provider;
|
|
let api_key = resolve_api_key(state, provider_name);
|
|
let model = state.settings.model.clone();
|
|
let api_base = resolve_api_base(state, provider_name);
|
|
|
|
// ── Build message list ─────────────────────────────────────────────
|
|
let mut messages: Vec<ChatMessage> = state
|
|
.session_runtime
|
|
.as_ref()
|
|
.map(|rt| rt.messages.clone())
|
|
.unwrap_or_default();
|
|
messages.push(ChatMessage::user(text));
|
|
|
|
if let Some(ref mut rt) = state.session_runtime {
|
|
rt.messages = messages.clone();
|
|
}
|
|
|
|
info!("Spawning agent turn (model: {model})");
|
|
|
|
// ── Assemble dependencies (composition root) ──────────────────────
|
|
let params = AgentTurnParams {
|
|
messages,
|
|
session_dir: session_dir.clone(),
|
|
workspace_roots: workspace_roots.clone(),
|
|
turn_events: turn_events.clone(),
|
|
in_flight: in_flight.clone(),
|
|
abort: abort.clone(),
|
|
api_key: api_key.clone(),
|
|
model: model.clone(),
|
|
api_base: api_base.clone(),
|
|
};
|
|
|
|
let client = std::sync::Arc::new(LlmClient::new(api_key, model, api_base));
|
|
|
|
let tool_ctx = ToolCtx::builder()
|
|
.session_dir(session_dir)
|
|
.workspaces(workspace_roots)
|
|
.turn_events(turn_events)
|
|
.build();
|
|
|
|
let tool_executor =
|
|
std::sync::Arc::new(InfrastructureToolExecutor::new(tool_ctx));
|
|
|
|
let tools = all_tools();
|
|
let defs = tool_defs(&tools);
|
|
|
|
let turn_service = AgentTurnServiceImpl::new(client, tool_executor, defs);
|
|
|
|
tokio::spawn(async move {
|
|
let _ = turn_service.run_turn(params).await;
|
|
});
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
|
|
#[test]
|
|
fn test_spawn_agent_turn_with_tokio_runtime() {
|
|
let rt = tokio::runtime::Runtime::new().unwrap();
|
|
let _guard = rt.enter();
|
|
|
|
let temp_dir = std::env::temp_dir().join(format!("zesdex_test_{}", uuid::Uuid::new_v4()));
|
|
let session_dir = temp_dir.join("session");
|
|
let memory_dir = temp_dir.join("memory");
|
|
std::fs::create_dir_all(&session_dir).unwrap();
|
|
std::fs::create_dir_all(&memory_dir).unwrap();
|
|
|
|
let workspace_roots = vec![temp_dir.clone()];
|
|
let mut state = AppStateRest::new(workspace_roots, &session_dir, memory_dir);
|
|
|
|
spawn_agent_turn(&mut state, "hello".to_string());
|
|
assert!(state.turn_in_flight());
|
|
|
|
let _ = std::fs::remove_dir_all(&temp_dir);
|
|
}
|
|
}
|