Function run_tool_loop

atomic-repository/src/ai/tools.rs:531–669

Run the agentic tool-use loop. The LLM can invoke tools up to `config.max_turns` times before a final text response is forced.

(
    provider: &LlmProvider,
    executor: &dyn ToolExecutor,
    query: &str,
    config: &AgentConfig,
)

/// Run the agentic tool-use loop. The LLM can invoke tools up to
/// `config.max_turns` times before a final text response is forced.
pub async fn run_tool_loop(
    provider: &LlmProvider,
    executor: &dyn ToolExecutor,
    query: &str,
    config: &AgentConfig,
) -> Result<AgentResult, AiError> {
    let tool_defs = executor.tool_definitions();

    let mut messages: Vec<ToolMessage> = Vec::new();
    if !config.system_prompt.is_empty() {
        messages.push(ToolMessage::System {
            content: config.system_prompt.clone(),
        });
    }
    messages.push(ToolMessage::User {
        content: query.to_string(),
    });

    let mut total_usage = TokenUsage::default();
    let mut tool_trace: Vec<ToolTraceEntry> = Vec::new();
    let mut turn: u8 = 0;
    let mut last_text = String::new(); // accumulate text across turns

    loop {
        turn += 1;
        let at_limit = turn > config.max_turns;

        // If we've exhausted turns, inject a prompt telling the LLM to
        // answer now with what it has, rather than removing tools (which
        // confuses the conversation flow after tool_use/tool_result pairs).
        if at_limit {
            messages.push(ToolMessage::User {
                content: "You have used all available tool turns. Please provide your \
                          answer now based on what you have found so far. Be concise \
                          and cite file paths and line numbers."
                    .to_string(),
            });
        }
        let tools_for_call = &tool_defs; // always provide tools
        let tokens_for_call = if at_limit {
            config.max_tokens.max(8192)
        } else {
            config.max_tokens
        };

        debug!(
            "tool loop turn {turn}/{} (tools={})",
            config.max_turns,
            tools_for_call.len()
        );

        let resp = provider
            .chat_with_tools(&messages, tools_for_call, tokens_for_call)
            .await?;

        total_usage.input_tokens += resp.usage.input_tokens;
        total_usage.output_tokens += resp.usage.output_tokens;
        total_usage.cache_read_tokens += resp.usage.cache_read_tokens;