Refactor subagent and workflow domain models; migrate access tiers and events to domain module

- Moved `AccessTier` and `SubagentEvent` enums to `zesdex_domain::subagent`.
- Consolidated workflow-related types into `zesdex_domain::workflow`.
- Updated references across the codebase to use the new domain models.
- Refactored tool execution logic to utilize a new `ToolExecutor` trait.
- Enhanced `AgentTurnService` to handle tool calls and events more effectively.
- Adjusted API handlers and state management to align with new domain structure.

apps/interfaces/api/src/handlers/chat.rs

@@ -121,7 +121,7 @@ pub async fn chat_completions_handler(
     let llm_client = if model == state.llm_client.model {
         &state.llm_client
     } else {
-        temp_client = zesdex_infrastructure::llm::LlmClient::new(
+        temp_client = zesdex_infrastructure::llm::provider::LlmClient::new(
             state.llm_client.api_key.clone(),
             model,
             Some(state.llm_client.base_url.clone()),
@@ -129,14 +129,14 @@ pub async fn chat_completions_handler(
         &temp_client
     };
 
+    use zesdex_application::ports::ProviderService;
     let (response, usage) = llm_client
-        .chat_with_tools_non_streaming(
+        .chat(
             &messages,
             None, // No tool definitions for basic chat
             req.max_tokens,
             req.temperature,
-            None, // No abort flag
-        )
+        ).await
         .map_err(|e| ApiError::ChatProxy(format!("LLM request failed: {e}")))?;
 
     let (prompt_tokens, completion_tokens) = usage.unwrap_or((0, 0));

apps/interfaces/api/src/state.rs

@@ -194,7 +194,7 @@ pub struct ApiState {
     pub token_service: JwtTokenService,
 
     /// LLM provider client for chat completions.
-    pub llm_client: zesdex_infrastructure::llm::LlmClient,
+    pub llm_client: zesdex_infrastructure::llm::provider::LlmClient,
 }
 
 impl fmt::Debug for ApiState {
@@ -272,7 +272,7 @@ impl ApiState {
             zesdex_application::cms::MemoryServiceImpl::new(memory_repo, memory_dir);
 
         let token_service = JwtTokenService::new(&jwt_secret);
-        let llm_client = zesdex_infrastructure::llm::LlmClient::new(
+        let llm_client = zesdex_infrastructure::llm::provider::LlmClient::new(
             llm_api_key.into(),
             llm_model.into(),
             llm_base_url,

apps/interfaces/daemon/src/handler.rs

@@ -320,19 +320,47 @@ fn handle_submit_input(state: &mut AppStateRest, text: String) {
         .map(|rt| rt.messages.clone())
         .unwrap_or_default();
 
-    let params = zesdex_infrastructure::agent::AgentTurnParams {
+    let params = zesdex_domain::agent::AgentTurnParams {
         messages,
         session_dir: state.session_dir.clone(),
         workspace_roots: state.workspace_roots.clone(),
         turn_events: state.turn_events.clone(),
         in_flight: std::sync::Arc::new(std::sync::atomic::AtomicBool::new(false)),
         abort: state.abort_flag.clone(),
-        api_key,
+        api_key: api_key.clone(),
         model: state.settings.model.clone(),
-        api_base: provider_cfg.map(|cfg| cfg.api_base.clone()),
+        api_base: provider_cfg.as_ref().map(|cfg| cfg.api_base.clone()),
     };
 
-    zesdex_infrastructure::agent::spawn_agent_turn(params);
+    let client = std::sync::Arc::new(zesdex_infrastructure::llm::provider::LlmClient::new(
+        api_key,
+        state.settings.model.clone(),
+        provider_cfg.map(|cfg| cfg.api_base.clone()),
+    ));
+
+    let tool_ctx = zesdex_infrastructure::tools::ToolCtx::builder()
+        .session_dir(state.session_dir.clone())
+        .workspaces(state.workspace_roots.clone())
+        .turn_events(state.turn_events.clone())
+        .build();
+
+    let tool_executor = std::sync::Arc::new(
+        zesdex_infrastructure::tools::executor::InfrastructureToolExecutor::new(tool_ctx),
+    );
+
+    let tools = zesdex_infrastructure::tools::all_tools();
+    let defs = zesdex_infrastructure::tools::tool_defs(&tools);
+
+    let turn_service = zesdex_application::agent::turn_service::AgentTurnServiceImpl::new(
+        client,
+        tool_executor,
+        defs,
+    );
+
+    use zesdex_application::agent::AgentTurnService;
+    tokio::spawn(async move {
+        let _ = turn_service.run_turn(params).await;
+    });
 }
 
 fn handle_delete_char(state: &mut AppStateRest) {
@@ -445,10 +473,11 @@ fn handle_compact(state: &mut AppStateRest) {
     let model = state.settings.model.clone();
     let api_base = provider_cfg.map(|cfg| cfg.api_base.clone());
 
-    let client = zesdex_infrastructure::llm::LlmClient::new(api_key, model, api_base);
+    let client = zesdex_infrastructure::llm::provider::LlmClient::new(api_key, model, api_base);
 
     if let Some(ref mut rt) = state.session_runtime {
-        if let Ok(()) = zesdex_infrastructure::agent::compact_messages_with_ai(&mut rt.messages, &client) {
+        let tokio_rt = tokio::runtime::Runtime::new().unwrap();
+        if let Ok(()) = tokio_rt.block_on(zesdex_application::agent::turn_service::compact_messages_with_ai(&mut rt.messages, &client)) {
             let msg_count = rt.messages.len();
             state.push_transcript(ChatMessageDisplay::new(
                 RoleWrapper::System,

apps/interfaces/tui/src/turn.rs

@@ -4,7 +4,7 @@ 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 zesdex_domain::agent::AgentTurnParams;
 use crate::state::AppStateRest;
 
 /// Spawn an agent turn on a background thread by delegating to `zesdex-infrastructure`.
@@ -63,15 +63,43 @@ pub fn spawn_agent_turn(state: &mut AppStateRest, text: String) {
 
     let params = AgentTurnParams {
         messages,
-        session_dir,
-        workspace_roots,
-        turn_events,
-        in_flight,
-        abort,
+        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(zesdex_infrastructure::llm::provider::LlmClient::new(
         api_key,
         model,
         api_base,
-    };
+    ));
 
-    backend_spawn_agent_turn(params);
+    let tool_ctx = zesdex_infrastructure::tools::ToolCtx::builder()
+        .session_dir(session_dir)
+        .workspaces(workspace_roots)
+        .turn_events(turn_events)
+        .build();
+
+    let tool_executor = std::sync::Arc::new(
+        zesdex_infrastructure::tools::executor::InfrastructureToolExecutor::new(tool_ctx),
+    );
+
+    let tools = zesdex_infrastructure::tools::all_tools();
+    let defs = zesdex_infrastructure::tools::tool_defs(&tools);
+
+    let turn_service = zesdex_application::agent::turn_service::AgentTurnServiceImpl::new(
+        client,
+        tool_executor,
+        defs,
+    );
+
+    use zesdex_application::agent::AgentTurnService;
+    tokio::spawn(async move {
+        let _ = turn_service.run_turn(params).await;
+    });
 }

apps/interfaces/ws/src/lib.rs

@@ -82,19 +82,47 @@ async fn handle_socket(mut socket: WebSocket, state: Arc<WsState>) {
                             let api_key = std::env::var("OPENAI_API_KEY").unwrap_or_default();
                             let model = val.get("model").and_then(|v| v.as_str()).unwrap_or("gpt-4o").to_string();
 
-                            let params = zesdex_infrastructure::agent::AgentTurnParams {
+                            let params = zesdex_domain::agent::AgentTurnParams {
                                 messages: vec![zesdex_domain::core::ChatMessage::user(prompt)],
-                                session_dir,
-                                workspace_roots,
+                                session_dir: session_dir.clone(),
+                                workspace_roots: workspace_roots.clone(),
                                 turn_events: turn_events.clone(),
                                 in_flight,
                                 abort,
-                                api_key,
-                                model,
+                                api_key: api_key.clone(),
+                                model: model.clone(),
                                 api_base: None,
                             };
 
-                            zesdex_infrastructure::agent::spawn_agent_turn(params);
+                            let client = std::sync::Arc::new(zesdex_infrastructure::llm::provider::LlmClient::new(
+                                api_key,
+                                model,
+                                None,
+                            ));
+
+                            let tool_ctx = zesdex_infrastructure::tools::ToolCtx::builder()
+                                .session_dir(session_dir)
+                                .workspaces(workspace_roots)
+                                .turn_events(turn_events.clone())
+                                .build();
+
+                            let tool_executor = std::sync::Arc::new(
+                                zesdex_infrastructure::tools::executor::InfrastructureToolExecutor::new(tool_ctx),
+                            );
+
+                            let tools = zesdex_infrastructure::tools::all_tools();
+                            let defs = zesdex_infrastructure::tools::tool_defs(&tools);
+
+                            let turn_service = zesdex_application::agent::turn_service::AgentTurnServiceImpl::new(
+                                client,
+                                tool_executor,
+                                defs,
+                            );
+
+                            use zesdex_application::agent::AgentTurnService;
+                            tokio::spawn(async move {
+                                let _ = turn_service.run_turn(params).await;
+                            });
 
                             let tx_clone = tx.clone();
                             tokio::spawn(async move {