zesdex/apps/infrastructure/src/subagent/engine.rs

//! Subagent engine — runs an LLM-powered agent with tool execution loop.
//!
//! Flow: construct system message → call LLM → parse tool calls → execute
//! tools → continue until the model returns a final text response (no more
//! tool calls) or the iteration limit is reached.
//!
//! Progress reporting: when a `TurnEvent` queue is available via the
//! `ToolCtx`, the engine emits `AgentProgress` events so the TUI can show
//! which tool the subagent is currently executing.

use anyhow::Result;
use tracing::{debug, info, instrument};

use crate::llm::provider::LlmClient;
use crate::subagent::context::SubagentContext;
use crate::subagent::division::{tools_for, AccessTier};
use crate::tools::{tool_defs, ToolCtx};
use zesdex_domain::agent::progress::AgentProgress;
use zesdex_domain::core::tool_call::sanitize_tool_arguments;
use zesdex_domain::core::ChatMessage;
use zesdex_domain::subagent_directive;

/// Maximum number of tool-call iterations before the engine gives up.
const MAX_ITERATIONS: u32 = 25;

/// Emit an `AgentProgress` event onto the turn-event queue, if one is
/// configured in the `ToolCtx`.
fn report_progress(tool_ctx: &ToolCtx, progress: AgentProgress) {
    if let Some(ref queue) = tool_ctx.turn_events {
        if let Ok(mut q) = queue.lock() {
            q.push_back(zesdex_domain::agent::TurnEvent::AgentProgress(progress));
        }
    }
}

/// Build the system message for a subagent, including current working
/// directory and workspace root information.
fn build_system_message(directive: &str, tool_ctx: &ToolCtx) -> ChatMessage {
    let cwd = std::env::current_dir()
        .map(|p| p.to_string_lossy().to_string())
        .unwrap_or_else(|_| "unknown".to_string());
    let ws_root = tool_ctx
        .workspaces
        .first()
        .map(|p| p.to_string_lossy().to_string())
        .unwrap_or_else(|| cwd.clone());

    ChatMessage::system(subagent_directive(directive, &cwd, &ws_root))
}

/// Run an agent with a directive, access tier, and tool context.
///
/// Flow:
///   1. Resolve allowed tools for the given `access` tier.
///   2. Build a system prompt from the directive using the domain prompt module.
///   3. Loop (up to `MAX_ITERATIONS`):
///      a. Call the LLM (non-streaming) with accumulated messages + tool defs.
///      b. If the response has no tool calls → return the text content.
///      c. Otherwise execute each tool call and append the result as a
///      tool-role message.
///      d. If the response also contained text, append an assistant message.
///   4. If the loop exits naturally, return the iteration-limit message.
///
/// Progress: each tool invocation is reported via `AgentProgress` if a
/// turn-event queue is available in the `ToolCtx`.
#[instrument(skip(ctx, tool_ctx))]
pub async fn run_agent(
    ctx: SubagentContext,
    directive: &str,
    access: AccessTier,
    tool_ctx: ToolCtx,
) -> Result<String> {
    info!("Subagent starting with directive: {directive}");

    let tools = tools_for(&access);
    let defs = tool_defs(&tools);

    let sys_msg = build_system_message(directive, &tool_ctx);

    let mut messages = vec![sys_msg];

    let client = LlmClient::new(
        ctx.api_key.clone(),
        ctx.model.clone(),
        Some(ctx.base_url.clone()),
    );

    // Limited iteration loop so we don't run forever
    for iteration in 0..MAX_ITERATIONS {
        use zesdex_application::ports::ProviderService;
        let (response_msg, _usage) = client
            .chat(&messages, Some(defs.clone()), Some(4096), None)
            .await?;

        let content = response_msg.content.clone().unwrap_or_default();
        let tool_calls = response_msg.tool_calls.unwrap_or_default();

        // If no tool calls, we're done — return content
        if tool_calls.is_empty() {
            info!("Subagent completed after {iteration} iterations");
            report_progress(
                &tool_ctx,
                AgentProgress::completed("subagent", directive),
            );
            return Ok(content);
        }

        // Execute tool calls
        for tc in &tool_calls {
            let tool_name = &tc.function.name;
            let args = sanitize_tool_arguments(&tc.function.arguments);

            debug!("Subagent executing tool: {tool_name}");

            report_progress(
                &tool_ctx,
                AgentProgress::running(
                    "subagent",
                    format!("{}:{}", directive, tool_name),
                    Some(tool_name.clone()),
                ),
            );

            let result =
                if let Some(tool) = tools.iter().find(|t| t.name() == tool_name) {
                    match tool.run(&tool_ctx, &args) {
                        Ok(output) => output,
                        Err(e) => format!("Error: {e}"),
                    }
                } else {
                    format!("Unknown tool: {tool_name}")
                };

            messages.push(ChatMessage::tool(tc.id.clone(), result));
        }

        // Add assistant response if there was text content
        if !content.is_empty() {
            messages.push(ChatMessage::assistant(Some(content)));
        }
    }

    info!("Subagent reached iteration limit ({MAX_ITERATIONS})");
    report_progress(
        &tool_ctx,
        AgentProgress::failed(
            "subagent",
            directive,
            format!("iteration limit ({MAX_ITERATIONS})"),
        ),
    );
    Ok(format!("Subagent reached iteration limit ({MAX_ITERATIONS})"))
}