zesdex/apps/interfaces/tui/src/turn.rs

//! TUI agent turn interface adapter — delegates execution to `zesdex_infrastructure::agent`.

use std::sync::atomic::Ordering;
use tracing::info;

use zesdex_domain::core::ChatMessage;
use zesdex_infrastructure::agent::{spawn_agent_turn as backend_spawn_agent_turn, AgentTurnParams};
use crate::state::AppStateRest;

/// Spawn an agent turn on a background thread by delegating to `zesdex-infrastructure`.
#[tracing::instrument(skip(state))]
pub fn spawn_agent_turn(state: &mut AppStateRest, text: String) {
    // compare_exchange: only mark in-flight if not already running
    if state
        .turn_in_flight_flag
        .compare_exchange(false, true, Ordering::SeqCst, Ordering::Relaxed)
        .is_err()
    {
        return; // already running
    }

    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 LLM provider configuration from settings
    let provider_name = &state.settings.provider;
    let provider_cfg = state.app_config.providers.get(provider_name).cloned();

    let mut api_key = String::new();
    if let Some(key) = state.settings.api_keys.get(provider_name) {
        api_key = key.clone();
    } else if let Some(ref cfg) = provider_cfg {
        if let Some(ref default_key) = cfg.default_api_key {
            api_key = default_key.clone();
        }
        if api_key.is_empty() {
            if let Some(ref env_name) = cfg.api_key_env {
                if let Ok(val) = std::env::var(env_name) {
                    api_key = val;
                }
            }
        }
    }

    let model = state.settings.model.clone();
    let api_base = provider_cfg.map(|cfg| cfg.api_base.clone());

    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!("delegating agent turn to infrastructure engine (model: {})", model);

    let params = AgentTurnParams {
        messages,
        session_dir,
        workspace_roots,
        turn_events,
        in_flight,
        abort,
        api_key,
        model,
        api_base,
    };

    backend_spawn_agent_turn(params);
}