ai_agent/

engine.rs

// Source: /data/home/swei/claudecode/openclaudecode/src/ink/layout/engine.ts
#![allow(dead_code)]

use crate::compact::{
    self, get_auto_compact_threshold, get_compact_prompt, get_effective_context_window_size,
};
use crate::services::compact::microcompact::truncate_tool_result_content;
use crate::error::AgentError;
use crate::hooks::{HookInput, HookRegistry};
use crate::tools::orchestration::{self, ToolMessageUpdate};
use crate::types::*;
use std::collections::HashMap;
use std::sync::{Arc, Mutex};

/// Strip thinking tags from content (remove "<think>" and "</think>" blocks)
/// Matches TypeScript's thinking removal logic
fn strip_thinking(content: &str) -> String {
    // Find and remove thinking blocks while preserving content between them
    // This handles UTF-8 correctly because we use string operations
    let mut result = String::new();
    let mut in_thinking = false;
    let mut i = 0;

    while i < content.len() {
        // Check for thinking start - must be at a valid char boundary
        if content[i..].starts_with("<think>") {
            in_thinking = true;
            i += "<think>".len();
        } else if content[i..].starts_with("</think>") {
            in_thinking = false;
            i += "</think>".len();
        } else if !in_thinking {
            // We're outside thinking block, add the character
            // Use char indices to avoid boundary issues
            if let Some(ch) = content[i..].chars().next() {
                result.push(ch);
                i += ch.len_utf8();
            } else {
                break;
            }
        } else {
            // We're inside thinking block, skip
            // Move to next character boundary
            if let Some(ch) = content[i..].chars().next() {
                i += ch.len_utf8();
            } else {
                break;
            }
        }
    }

    result.trim().to_string()
}

/// Parse Anthropic API usage info
fn parse_anthropic_usage(usage: &serde_json::Value) -> TokenUsage {
    TokenUsage {
        input_tokens: usage
            .get("input_tokens")
            .and_then(|v| v.as_u64())
            .unwrap_or(0),
        output_tokens: usage
            .get("output_tokens")
            .and_then(|v| v.as_u64())
            .unwrap_or(0),
        cache_creation_input_tokens: usage
            .get("cache_creation_input_tokens")
            .and_then(|v| v.as_u64()),
        cache_read_input_tokens: usage
            .get("cache_read_input_tokens")
            .and_then(|v| v.as_u64()),
    }
}

/// Tracks auto-compaction state across iterations
#[derive(Debug, Clone, Default)]
pub struct AutoCompactTracking {
    /// Whether a compaction happened in the previous turn
    pub compacted: bool,
    /// Counter for turns since previous compact
    pub turn_counter: u32,
    /// Consecutive auto-compact failure count (circuit breaker)
    pub consecutive_failures: u32,
}

#[allow(dead_code)]
pub struct QueryEngine {
    config: QueryEngineConfig,
    messages: Vec<crate::types::Message>,
    turn_count: u32,
    total_usage: TokenUsage,
    total_cost: f64,
    http_client: reqwest::Client,
    /// Tool executors: name -> async function
    tool_executors: Mutex<HashMap<String, Arc<ToolExecutor>>>,
    /// Hook registry for PreToolUse/PostToolUse hooks
    hook_registry: Arc<Mutex<Option<HookRegistry>>>,
    /// Auto-compaction tracking state
    auto_compact_tracking: AutoCompactTracking,
    /// Track permission denials for SDK reporting (matches TypeScript)
    permission_denials: Vec<PermissionDenial>,
    /// Last stop_reason from assistant messages
    last_stop_reason: Option<String>,
}

type BoxFuture<T> = std::pin::Pin<Box<dyn std::future::Future<Output = T> + Send>>;
type ToolExecutor = dyn Fn(serde_json::Value, &ToolContext) -> BoxFuture<Result<ToolResult, AgentError>>
    + Send
    + Sync;

/// Permission denial tracking for SDK reporting
#[derive(Debug, Clone, Default)]
pub struct PermissionDenial {
    pub tool_name: String,
    pub tool_use_id: String,
    pub tool_input: serde_json::Value,
}

pub struct QueryEngineConfig {
    pub cwd: String,
    pub model: String,
    pub api_key: Option<String>,
    pub base_url: Option<String>,
    pub tools: Vec<ToolDefinition>,
    pub system_prompt: Option<String>,
    pub max_turns: u32,
    pub max_budget_usd: Option<f64>,
    pub max_tokens: u32,
    /// Permission check function - called BEFORE tool execution
    /// Returns true if tool can be used, false if denied
    pub can_use_tool: Option<fn(ToolDefinition, serde_json::Value) -> bool>,
    /// Callback for agent events (tool start/complete/error, thinking, done)
    pub on_event: Option<std::sync::Arc<dyn Fn(AgentEvent) + Send + Sync>>,
}

impl Default for QueryEngineConfig {
    fn default() -> Self {
        Self {
            cwd: String::new(),
            model: String::new(),
            api_key: None,
            base_url: None,
            tools: vec![],
            system_prompt: None,
            max_turns: 10,
            max_budget_usd: None,
            max_tokens: 16384,
            can_use_tool: None,
            on_event: None,
        }
    }
}

impl QueryEngine {
    pub fn new(config: QueryEngineConfig) -> Self {
        Self {
            config,
            messages: vec![],
            turn_count: 0,
            total_usage: TokenUsage {
                input_tokens: 0,
                output_tokens: 0,
                cache_creation_input_tokens: None,
                cache_read_input_tokens: None,
            },
            total_cost: 0.0,
            http_client: reqwest::Client::new(),
            tool_executors: Mutex::new(HashMap::new()),
            hook_registry: Arc::new(Mutex::new(None)),
            auto_compact_tracking: AutoCompactTracking::default(),
            permission_denials: Vec::new(),
            last_stop_reason: None,
        }
    }

    /// Register a tool executor
    pub fn register_tool<F>(&mut self, name: String, executor: F)
    where
        F: Fn(serde_json::Value, &ToolContext) -> BoxFuture<Result<ToolResult, AgentError>>
            + Send
            + Sync
            + 'static,
    {
        self.tool_executors
            .lock()
            .unwrap()
            .insert(name, Arc::new(executor));
    }

    /// Set initial messages (for continuing a conversation)
    pub fn set_messages(&mut self, messages: Vec<crate::types::Message>) {
        self.messages = messages;
    }

    /// Execute a tool by name
    pub async fn execute_tool(
        &mut self,
        name: &str,
        input: serde_json::Value,
    ) -> Result<ToolResult, AgentError> {
        let context = ToolContext {
            cwd: self.config.cwd.clone(),
            abort_signal: None,
        };

        // Clone the Arc out of the map
        let executor = {
            let executors = self.tool_executors.lock().unwrap();
            executors.get(name).cloned()
        };

        if let Some(executor) = executor {
            // PRE-TOOL PERMISSION CHECK - matches TypeScript's wrappedCanUseTool
            // Check if tool is allowed before execution
            let tool_use_id = uuid::Uuid::new_v4().to_string();
            if let Some(can_use_tool_fn) = &self.config.can_use_tool {
                // Find the tool definition
                if let Some(tool_def) = self.config.tools.iter().find(|t| &t.name == name) {
                    // Call can_use_tool to check permission
                    if !can_use_tool_fn(tool_def.clone(), input.clone()) {
                        // Tool denied - track for SDK reporting and return error
                        self.permission_denials.push(PermissionDenial {
                            tool_name: name.to_string(),
                            tool_use_id: tool_use_id.clone(),
                            tool_input: input.clone(),
                        });
                        return Err(AgentError::Tool(format!(
                            "Tool '{}' permission denied",
                            name
                        )));
                    }
                }
            }

            // Continue with execution
            // Run PreToolUse hooks
            let tool_use_id = uuid::Uuid::new_v4().to_string();

            // Emit ToolStart event
            if let Some(ref cb) = self.config.on_event {
                cb(AgentEvent::ToolStart {
                    tool_name: name.to_string(),
                    tool_call_id: tool_use_id.clone(),
                    input: input.clone(),
                });
            }

            self.run_pre_tool_use_hooks(name, &input, &tool_use_id)
                .await?;

            // Execute the tool
            let result = executor(input, &context).await;

            // Emit ToolComplete or ToolError event
            if let Some(ref cb) = self.config.on_event {
                match &result {
                    Ok(tool_result) => {
                        cb(AgentEvent::ToolComplete {
                            tool_name: name.to_string(),
                            tool_call_id: tool_use_id.clone(),
                            result: tool_result.clone(),
                        });
                    }
                    Err(e) => {
                        cb(AgentEvent::ToolError {
                            tool_name: name.to_string(),
                            tool_call_id: tool_use_id.clone(),
                            error: e.to_string(),
                        });
                    }
                }
            }

            // Run PostToolUse or PostToolUseFailure hooks
            match &result {
                Ok(tool_result) => {
                    self.run_post_tool_use_hooks(name, tool_result, &tool_use_id)
                        .await;
                }
                Err(e) => {
                    self.run_post_tool_use_failure_hooks(name, e, &tool_use_id)
                        .await;
                }
            }

            result
        } else {
            Err(AgentError::Tool(format!("Tool '{}' not found", name)))
        }
    }

    /// Set the hook registry
    pub fn set_hook_registry(&self, registry: HookRegistry) {
        let mut guard = self.hook_registry.lock().unwrap();
        *guard = Some(registry);
    }

    /// Set the event callback for agent events (tool start/complete/error, thinking, done)
    pub fn set_event_callback<F>(&mut self, callback: F)
    where
        F: Fn(AgentEvent) + Send + Sync + 'static,
    {
        self.config.on_event = Some(std::sync::Arc::new(callback));
    }

    /// Run PreToolUse hooks
    async fn run_pre_tool_use_hooks(
        &self,
        tool_name: &str,
        tool_input: &serde_json::Value,
        tool_use_id: &str,
    ) -> Result<(), AgentError> {
        // First check if we have hooks (outside of lock)
        let has_hooks = {
            let guard = self.hook_registry.lock().unwrap();
            guard
                .as_ref()
                .map(|r| r.has_hooks("PreToolUse"))
                .unwrap_or(false)
        };

        if !has_hooks {
            return Ok(());
        }

        // Build input outside of lock
        let input = HookInput {
            event: "PreToolUse".to_string(),
            tool_name: Some(tool_name.to_string()),
            tool_input: Some(tool_input.clone()),
            tool_output: None,
            tool_use_id: Some(tool_use_id.to_string()),
            session_id: None,
            cwd: Some(self.config.cwd.clone()),
            error: None,
        };

        // Execute hooks (registry is Clone and Arc-wrapped, so we can clone the reference)
        let registry = {
            let guard = self.hook_registry.lock().unwrap();
            guard.as_ref().cloned()
        };

        if let Some(registry) = registry {
            let results = registry.execute("PreToolUse", input).await;

            // Check if any hook blocked the tool use
            for output in results {
                if let Some(block) = output.block {
                    if block {
                        return Err(AgentError::Tool(format!(
                            "Tool '{}' blocked by PreToolUse hook",
                            tool_name
                        )));
                    }
                }
            }
        }
        Ok(())
    }

    /// Run PostToolUse hooks
    async fn run_post_tool_use_hooks(
        &self,
        tool_name: &str,
        tool_output: &ToolResult,
        tool_use_id: &str,
    ) {
        let has_hooks = {
            let guard = self.hook_registry.lock().unwrap();
            guard
                .as_ref()
                .map(|r| r.has_hooks("PostToolUse"))
                .unwrap_or(false)
        };

        if !has_hooks {
            return;
        }

        let input = HookInput {
            event: "PostToolUse".to_string(),
            tool_name: Some(tool_name.to_string()),
            tool_input: None,
            tool_output: Some(serde_json::json!({
                "result_type": tool_output.result_type,
                "content": tool_output.content,
                "is_error": tool_output.is_error,
            })),
            tool_use_id: Some(tool_use_id.to_string()),
            session_id: None,
            cwd: Some(self.config.cwd.clone()),
            error: None,
        };

        let registry = {
            let guard = self.hook_registry.lock().unwrap();
            guard.as_ref().cloned()
        };

        if let Some(registry) = registry {
            let _ = registry.execute("PostToolUse", input).await;
        }
    }

    /// Run PostToolUseFailure hooks
    async fn run_post_tool_use_failure_hooks(
        &self,
        tool_name: &str,
        error: &AgentError,
        tool_use_id: &str,
    ) {
        let has_hooks = {
            let guard = self.hook_registry.lock().unwrap();
            guard
                .as_ref()
                .map(|r| r.has_hooks("PostToolUseFailure"))
                .unwrap_or(false)
        };

        if !has_hooks {
            return;
        }

        let input = HookInput {
            event: "PostToolUseFailure".to_string(),
            tool_name: Some(tool_name.to_string()),
            tool_input: None,
            tool_output: None,
            tool_use_id: Some(tool_use_id.to_string()),
            session_id: None,
            cwd: Some(self.config.cwd.clone()),
            error: Some(error.to_string()),
        };

        let registry = {
            let guard = self.hook_registry.lock().unwrap();
            guard.as_ref().cloned()
        };

        if let Some(registry) = registry {
            let _ = registry.execute("PostToolUseFailure", input).await;
        }
    }

    pub fn get_turn_count(&self) -> u32 {
        self.turn_count
    }

    /// Get total token usage from all API calls
    pub fn get_usage(&self) -> TokenUsage {
        self.total_usage.clone()
    }

    pub fn get_messages(&self) -> Vec<crate::types::Message> {
        self.messages.clone()
    }

    /// Attempt to auto-compact the conversation when token count exceeds threshold
    /// Uses LLM to generate a summary of the conversation (matching TypeScript's compactConversation)
    /// Returns Ok(true) if compaction happened, Ok(false) if not needed, Err on failure
    async fn do_auto_compact(&mut self) -> Result<bool, AgentError> {
        let token_count = compact::estimate_token_count(&self.messages, self.config.max_tokens);
        let threshold = get_auto_compact_threshold(&self.config.model);

        // Check if we need to compact
        if token_count <= threshold {
            return Ok(false);
        }

        // Generate summary using LLM
        let summary = self.generate_summary().await?;

        // Keep a few recent messages (last 4) to preserve immediate context
        let keep_last = 4;
        let messages_to_keep: Vec<Message> = if self.messages.len() > keep_last {
            self.messages[self.messages.len() - keep_last..].to_vec()
        } else {
            self.messages.clone()
        };

        // Create boundary message with summary
        let boundary_msg = Message {
            role: MessageRole::System,
            content: format!("[Previous conversation summarized]\n\n{}", summary),
            ..Default::default()
        };

        // Create new message list: boundary + recent messages
        let mut new_messages = vec![boundary_msg];
        new_messages.extend(messages_to_keep);

        let _new_token_count = compact::estimate_token_count(&new_messages, self.config.max_tokens);

        self.messages = new_messages;
        Ok(true)
    }

    /// Generate a summary of the conversation using LLM
    /// Translated from: compactConversation in compact.ts
    async fn generate_summary(&self) -> Result<String, AgentError> {
        let compact_prompt = get_compact_prompt();

        // Build messages for summary request - use all current messages
        let mut summary_messages = vec![Message {
            role: MessageRole::User,
            content: compact_prompt,
            ..Default::default()
        }];

        // Add conversation messages (excluding any existing system boundary messages)
        for msg in &self.messages {
            if let MessageRole::System = msg.role {
                // Skip system boundary messages - they're from previous compactions
                if msg.content.contains("compacted") || msg.content.contains("summarized") {
                    continue;
                }
            }
            summary_messages.push(msg.clone());
        }

        // If messages are too large for the context window, truncate them
        // This ensures we can at least attempt summarization
        let max_summary_tokens = 2048u32; // Reduced to leave more room for input
        let (truncated_summary_messages, estimated_tokens) = compact::truncate_messages_for_summary(
            &summary_messages,
            &self.config.model,
            max_summary_tokens,
        );

        // Verify it's safe before proceeding
        if estimated_tokens > 150000 {
            return Err(AgentError::Api(format!(
                "Cannot generate summary: estimated {} tokens exceeds safe limit",
                estimated_tokens
            )));
        }

        // Use truncated messages for summary generation
        let summary_messages = truncated_summary_messages;

        // Get API configuration
        let api_key = self
            .config
            .api_key
            .as_ref()
            .ok_or_else(|| AgentError::Api("API key not provided".to_string()))?;

        let base_url = self
            .config
            .base_url
            .as_ref()
            .map(|s| s.as_str())
            .unwrap_or("https://api.anthropic.com");

        // For summary, use faster/cheaper model if available, or same model
        let model = &self.config.model;

        // Convert messages to API format (with proper role handling)
        // Tool results must use 'user' role per OpenAI/vLLM API spec
        let api_summary_messages: Vec<serde_json::Value> = summary_messages
            .iter()
            .map(|msg| {
                let role_str = match msg.role {
                    MessageRole::User => "user",
                    MessageRole::Assistant => "assistant",
                    MessageRole::Tool => "user", // Tool results use 'user' role
                    MessageRole::System => "system",
                };
                let mut msg_json = serde_json::json!({
                    "role": role_str,
                    "content": msg.content
                });
                if let Some(tool_call_id) = &msg.tool_call_id {
                    msg_json["tool_call_id"] = serde_json::json!(tool_call_id);
                }
                msg_json
            })
            .collect();

        // Build request - use OpenAI format for vLLM compatibility
        // Use smaller max_tokens to avoid hitting token limits during summarization
        let request_body = serde_json::json!({
            "model": model,
            "max_tokens": 2048,
            "messages": api_summary_messages,
        });

        let client = reqwest::Client::new();
        let url = format!("{}/v1/chat/completions", base_url);
        let response = client
            .post(&url)
            .header("Authorization", format!("Bearer {}", api_key))
            .header("Content-Type", "application/json")
            .json(&request_body)
            .send()
            .await
            .map_err(|e| AgentError::Api(format!("Failed to send summary request: {}", e)))?;

        let response_text = response
            .text()
            .await
            .map_err(|e| AgentError::Api(format!("Failed to read summary response: {}", e)))?;

        // Parse response
        let response_json: serde_json::Value =
            serde_json::from_str(&response_text).map_err(|e| {
                AgentError::Api(format!(
                    "Failed to parse summary response: {} - {}",
                    e, response_text
                ))
            })?;

        // Extract summary text from response
        if let Some(error) = response_json.get("error") {
            return Err(AgentError::Api(format!("Summary API error: {}", error)));
        }

        // Extract content from OpenAI response format
        let summary = extract_text_from_response(&response_json);

        if summary.is_empty() {
            return Err(AgentError::Api("Summary response was empty".to_string()));
        }

        // Parse the summary to extract just the <summary> content
        // The prompt asks for <analysis> and <summary> blocks
        let parsed_summary = parse_compact_summary(&summary);

        Ok(parsed_summary)
    }

    pub async fn submit_message(&mut self, prompt: &str) -> Result<(String, crate::types::ExitReason), AgentError> {
        // Add user message to history
        self.messages.push(crate::types::Message {
            role: crate::types::MessageRole::User,
            content: prompt.to_string(),
            ..Default::default()
        });

        // Note: max_turns check is done AFTER turn completes (matching TypeScript)
        // See below after tool execution loop for the check

        // Check auto-compact BEFORE entering tool loop - don't wait until after API call
        // This ensures we compact before hitting the token limit
        let threshold = get_auto_compact_threshold(&self.config.model);
        let token_count = compact::estimate_token_count(&self.messages, self.config.max_tokens);

        if self.auto_compact_tracking.consecutive_failures < 3 && token_count > threshold {
            // Try to compact before making any API call
            match self.do_auto_compact().await {
                Ok(true) => {
                    // Compaction succeeded, continue with compacted messages
                    self.auto_compact_tracking.compacted = true;
                    self.auto_compact_tracking.consecutive_failures = 0;
                }
                Ok(false) => {
                    // No compaction needed or possible
                }
                Err(e) => {
                    // Compaction failed, continue anyway
                    self.auto_compact_tracking.consecutive_failures += 1;
                    eprintln!("Auto-compact failed: {}", e);
                }
            }
        }

        // Emit Thinking event for the first turn before the first API call
        // Initialize turn_count to 0, will be incremented before next Thinking event
        if let Some(ref cb) = self.config.on_event {
            cb(AgentEvent::Thinking { turn: 1 });
        }

        // Tool call loop - continue until no more tool calls
        let mut max_tool_turns = 10;
        while max_tool_turns > 0 {
            max_tool_turns -= 1;

            // Update turn counter for auto-compact tracking
            self.auto_compact_tracking.turn_counter += 1;

            // Check if we should auto-compact based on token count (after tool execution)
            let token_count = compact::estimate_token_count(&self.messages, self.config.max_tokens);
            let threshold = get_auto_compact_threshold(&self.config.model);
            let _effective_window = get_effective_context_window_size(&self.config.model);

            // Only attempt auto-compact if:
            // 1. Not disabled by circuit breaker (max 3 consecutive failures)
            // 2. Token count exceeds auto-compact threshold
            if self.auto_compact_tracking.consecutive_failures < 3 && token_count > threshold {
                // Attempt auto-compact
                match self.do_auto_compact().await {
                    Ok(true) => {
                        // Compaction succeeded, continue with compacted messages
                        self.auto_compact_tracking.compacted = true;
                        self.auto_compact_tracking.consecutive_failures = 0;
                        // Rebuild api_messages after compaction
                        continue;
                    }
                    Ok(false) => {
                        // No compaction needed or possible
                    }
                    Err(e) => {
                        // Compaction failed, increment failure counter
                        self.auto_compact_tracking.consecutive_failures += 1;
                        eprintln!("Auto-compact failed: {}", e);
                    }
                }
            }

            // Reset compacted flag for next iteration
            self.auto_compact_tracking.compacted = false;

            // Build messages for API
            let api_messages = self.build_api_messages()?;

            // Get API configuration
            let api_key = self
                .config
                .api_key
                .as_ref()
                .ok_or_else(|| AgentError::Api("API key not provided".to_string()))?;

            let base_url = self
                .config
                .base_url
                .as_ref()
                .map(|s| s.as_str())
                .unwrap_or("https://api.anthropic.com");

            let model = &self.config.model;

            // Build request with tools if available
            // Always use streaming for all backends (matching TypeScript behavior)
            // Non-streaming fallback will be used if streaming fails
            let mut request_body = serde_json::json!({
                "model": model,
                "max_tokens": self.config.max_tokens,
                "messages": api_messages,
                "stream": true
            });

            // Add system prompt to request body (Anthropic uses separate field)
            if let Some(system_prompt) = &self.config.system_prompt {
                request_body["system"] = serde_json::json!(system_prompt);
            }

            // Add tools to request if we have any
            if !self.config.tools.is_empty() {
                // Determine tool format based on API endpoint:
                // - Anthropic /v1/messages uses Anthropic format
                // - OpenAI-compatible /v1/chat/completions uses OpenAI format
                // When streaming is enabled, OpenAI-compatible backends need OpenAI format
                let use_anthropic_format = base_url.contains("anthropic.com");

                let tools: Vec<serde_json::Value> = self
                    .config
                    .tools
                    .iter()
                    .map(|t| {
                        if use_anthropic_format {
                            // Anthropic format (works with Anthropic API, and some vLLM with stream:false)
                            // Note: vLLM with streaming requires OpenAI format
                            serde_json::json!({
                                "type": "function",
                                "name": t.name,
                                "description": t.description,
                                "input_schema": t.input_schema
                            })
                        } else {
                            // OpenAI format: name, description, parameters nested under "function"
                            // Required for: OpenAI API, vLLM with streaming, LiteLLM, etc.
                            serde_json::json!({
                                "type": "function",
                                "function": {
                                    "name": t.name,
                                    "description": t.description,
                                    "parameters": t.input_schema
                                }
                            })
                        }
                    })
                    .collect();
                request_body["tools"] = serde_json::json!(tools);
            }

            // Determine API endpoint and auth format based on backend
            // Anthropic uses /v1/messages, OpenAI-compatible uses /v1/chat/completions
            let url = if base_url.contains("anthropic.com") {
                format!("{}/v1/messages", base_url)
            } else {
                format!("{}/v1/chat/completions", base_url)
            };

            // Try streaming first, with fallback to non-streaming on failure
            // This matches TypeScript's behavior
            let streaming_result = match make_anthropic_streaming_request(
                &self.http_client,
                &url,
                api_key,
                request_body.clone(),
                self.config.on_event.clone(),
            )
            .await
            {
                Ok(result) => result,
                Err(e) => {
                    // Streaming failed - fall back to non-streaming
                    // This matches TypeScript's non-streaming fallback logic
                    eprintln!("Streaming failed, falling back to non-streaming: {}", e);

                    // Make non-streaming request
                    make_nonstreaming_request(
                        &self.http_client,
                        &url,
                        api_key,
                        request_body,
                        self.config.on_event.clone(),
                    )
                    .await?
                }
            };

            // Check for tool calls in the streaming result
            if streaming_result.tool_calls.is_empty() {
                // No tool calls - this is the final response
                let response_text = streaming_result.content;

                // Strip thinking tags and return
                // If cleaned is empty but original had content, use original (model may have only produced thinking)
                let cleaned = strip_thinking(&response_text);
                let final_text = if cleaned.is_empty() && !response_text.is_empty() {
                    response_text.clone()
                } else {
                    cleaned
                };

                // Update total usage
                self.total_usage.input_tokens += streaming_result.usage.input_tokens;
                self.total_usage.output_tokens += streaming_result.usage.output_tokens;

                // Add assistant response to message history
                self.messages.push(crate::types::Message {
                    role: crate::types::MessageRole::Assistant,
                    content: response_text.clone(),
                    ..Default::default()
                });

                // Check max_turns limit BEFORE incrementing (TypeScript checks nextTurnCount before increment)
                let next_turn_count = self.turn_count + 1;
                if self.config.max_turns > 0 && next_turn_count > self.config.max_turns {
                    // Emit max_turns_reached event (matches TypeScript behavior)
                    if let Some(ref cb) = self.config.on_event {
                        cb(AgentEvent::MaxTurnsReached {
                            max_turns: self.config.max_turns,
                            turn_count: next_turn_count,
                        });
                    }
                    // Return what we have, don't exceed max turns
                    return Ok((final_text, crate::types::ExitReason::MaxTurns {
                        max_turns: self.config.max_turns,
                        turn_count: next_turn_count,
                    }));
                }

                // Increment turn_count AFTER tool execution (matches TypeScript behavior)
                self.turn_count = next_turn_count;

                // Emit Thinking event for next turn
                if let Some(ref cb) = self.config.on_event {
                    cb(AgentEvent::Thinking {
                        turn: self.turn_count,
                    });
                }

                // Return the final text (already processed above)
                return Ok((final_text, crate::types::ExitReason::Completed));
            }

            // Process tool calls from streaming result
            let tool_calls = streaming_result.tool_calls;

            // Convert JSON tool calls to ToolCall structs
            let mut tool_call_structs: Vec<crate::types::ToolCall> = Vec::new();
            for tc in &tool_calls {
                let name = tc.get("name").and_then(|n| n.as_str()).unwrap_or("").to_string();
                let id = tc.get("id").and_then(|i| i.as_str()).unwrap_or("").to_string();
                let arguments = tc.get("arguments").cloned().unwrap_or(serde_json::Value::Null);
                tool_call_structs.push(crate::types::ToolCall {
                    id,
                    name,
                    arguments,
                });
            }

            // Use orchestration for concurrent/serial tool execution
            // This matches TypeScript's runTools() with partitioning
            let tool_context = crate::types::ToolContext {
                cwd: self.config.cwd.clone(),
                abort_signal: None,
            };

            // Create executor closure using the tool executors stored in QueryEngine
            // Wrap in Arc so it can be cloned for concurrent execution
            let tool_executors = Arc::new(self.tool_executors.lock().unwrap().clone());
            let tools = self.config.tools.clone();
            let can_use_tool = self.config.can_use_tool;
            let cwd = self.config.cwd.clone();
            let on_event = self.config.on_event.clone();

            let executor = move |name: String, args: serde_json::Value, tool_call_id: String| {
                let tool_executors = tool_executors.clone();
                let tools = tools.clone();
                let can_use_tool = can_use_tool;
                let cwd = cwd.clone();
                let on_event = on_event.clone();
                async move {
                    // Emit ToolStart event - use the tool_call_id from API response
                    if let Some(ref cb) = on_event {
                        cb(AgentEvent::ToolStart {
                            tool_name: name.clone(),
                            tool_call_id: tool_call_id.clone(),
                            input: args.clone(),
                        });
                    }

                    // Execute tool directly using stored executors
                    let context = crate::types::ToolContext {
                        cwd,
                        abort_signal: None,
                    };

                    let executor = tool_executors.get(&name).cloned();

                    if let Some(executor) = executor {
                        // Pre-tool permission check
                        if let Some(can_use_fn) = can_use_tool {
                            if let Some(tool_def) = tools.iter().find(|t| &t.name == &name) {
                                if !can_use_fn(tool_def.clone(), args.clone()) {
                                    return Err(crate::error::AgentError::Tool(format!(
                                        "Tool '{}' permission denied",
                                        name
                                    )));
                                }
                            }
                        }

                        let result = executor(args, &context).await;

                        // Emit ToolComplete or ToolError event
                        if let Some(ref cb) = on_event {
                            match &result {
                                Ok(tool_result) => {
                                    cb(AgentEvent::ToolComplete {
                                        tool_name: name.clone(),
                                        tool_call_id: tool_call_id.clone(),
                                        result: tool_result.clone(),
                                    });
                                }
                                Err(e) => {
                                    cb(AgentEvent::ToolError {
                                        tool_name: name.clone(),
                                        tool_call_id: tool_call_id.clone(),
                                        error: e.to_string(),
                                    });
                                }
                            }
                        }

                        result
                    } else {
                        let err = crate::error::AgentError::Tool(format!(
                            "Tool '{}' not found",
                            name
                        ));
                        // Emit ToolError event
                        if let Some(ref cb) = on_event {
                            cb(AgentEvent::ToolError {
                                tool_name: name.clone(),
                                tool_call_id: tool_call_id.clone(),
                                error: err.to_string(),
                            });
                        }
                        Err(err)
                    }
                }
            };

            // Add assistant message with tool_calls to history BEFORE execution
            // This matches TypeScript behavior - the assistant message contains tool call info
            let assistant_msg = crate::types::Message {
                role: crate::types::MessageRole::Assistant,
                content: format!("Calling tool(s): {:?}", tool_calls.iter().map(|tc| tc.get("name").and_then(|n| n.as_str()).unwrap_or("")).collect::<Vec<_>>()),
                tool_calls: Some(tool_call_structs.clone()),
                ..Default::default()
            };
            self.messages.push(assistant_msg);

            let updates = orchestration::run_tools(
                tool_call_structs,
                self.config.tools.clone(),
                tool_context,
                executor,
            )
            .await;

            // Process tool results - matches TypeScript's normalizeMessagesForAPI
            for update in updates {
                if let Some(message) = update.message {
                    // Add tool result message to history
                    // Truncate large tool results to prevent 413 Payload Too Large errors
                    let truncated_content =
                        truncate_tool_result_content(&message.content, "");
                    let mut msg = message;
                    msg.content = truncated_content;
                    self.messages.push(msg);
                }
            }

            // After tool execution, check max_turns BEFORE incrementing
            let next_turn_count = self.turn_count + 1;
            if self.config.max_turns > 0 && next_turn_count > self.config.max_turns {
                // Emit max_turns_reached event
                if let Some(ref cb) = self.config.on_event {
                    cb(AgentEvent::MaxTurnsReached {
                        max_turns: self.config.max_turns,
                        turn_count: next_turn_count,
                    });
                }
                // Return what we have, don't exceed max turns
                let final_text = self
                    .messages
                    .iter()
                    .filter(|m| m.role == crate::types::MessageRole::Assistant)
                    .last()
                    .map(|m| m.content.clone())
                    .unwrap_or_else(|| "Max turns reached".to_string());
                let final_text = strip_thinking(&final_text);
                if let Some(ref cb) = self.config.on_event {
                    cb(AgentEvent::Done {
                        result: crate::types::QueryResult {
                            text: final_text.clone(),
                            usage: self.total_usage.clone(),
                            num_turns: self.turn_count,
                            duration_ms: 0,
                            exit_reason: crate::types::ExitReason::default(),
                        },
                    });
                }
                return Ok((final_text, crate::types::ExitReason::default()));
            }

            // After tool execution, increment turn count
            // TypeScript increments once per full turn (user msg + assistant + tools)
            self.turn_count = next_turn_count;

            // Emit Thinking event for next turn
            if let Some(ref cb) = self.config.on_event {
                cb(AgentEvent::Thinking {
                    turn: self.turn_count,
                });
            }

            // Continue the loop to get next response
        }

        // Max tool turns reached
        let final_text = self
            .messages
            .iter()
            .filter(|m| m.role == crate::types::MessageRole::Assistant)
            .last()
            .map(|m| m.content.clone())
            .unwrap_or_else(|| "Max tool execution turns reached".to_string());

        // Strip thinking tags from final text
        let final_text = strip_thinking(&final_text);

        // Emit Done event
        if let Some(ref cb) = self.config.on_event {
            cb(AgentEvent::Done {
                result: crate::types::QueryResult {
                    text: final_text.clone(),
                    usage: self.total_usage.clone(),
                    num_turns: self.turn_count,
                    duration_ms: 0, // Could track start time for accurate duration
                    exit_reason: crate::types::ExitReason::Completed,
                },
            });
        }

        Ok((final_text, crate::types::ExitReason::Completed))
    }

    fn build_api_messages(&self) -> Result<Vec<serde_json::Value>, AgentError> {
        // Determine if this is Anthropic API or OpenAI-compatible
        let base_url = self.config.base_url.as_deref().unwrap_or("https://api.anthropic.com");
        let is_anthropic = base_url.contains("anthropic.com");

        let mut api_messages: Vec<serde_json::Value> = Vec::new();

        // Note: System prompt is handled separately in the request body, not in messages array

        for msg in &self.messages {
            match msg.role {
                crate::types::MessageRole::User => {
                    // User message - simple text content
                    api_messages.push(serde_json::json!({
                        "role": "user",
                        "content": msg.content
                    }));
                }
                crate::types::MessageRole::Assistant => {
                    // Assistant message - could have tool_use blocks
                    if let Some(tool_calls) = &msg.tool_calls {
                        if is_anthropic {
                            // Anthropic format: content array with text and tool_use blocks
                            let mut content_blocks: Vec<serde_json::Value> = Vec::new();

                            // Add text content if present
                            if !msg.content.is_empty()
                                && msg.content
                                    != format!(
                                        "Calling tool: {} with args: ",
                                        tool_calls.first().map(|t| t.name.as_str()).unwrap_or("")
                                    )
                            {
                                content_blocks.push(serde_json::json!({
                                    "type": "text",
                                    "text": msg.content
                                }));
                            }

                            // Add tool_use blocks
                            for tc in tool_calls {
                                content_blocks.push(serde_json::json!({
                                    "type": "tool_use",
                                    "id": tc.id,
                                    "name": tc.name,
                                    "input": tc.arguments
                                }));
                            }

                            api_messages.push(serde_json::json!({
                                "role": "assistant",
                                "content": content_blocks
                            }));
                        } else {
                            // OpenAI format: separate content and tool_calls fields
                            // Build tool_calls array
                            let mut openai_tool_calls: Vec<serde_json::Value> = Vec::new();
                            for tc in tool_calls {
                                openai_tool_calls.push(serde_json::json!({
                                    "id": tc.id,
                                    "type": "function",
                                    "function": {
                                        "name": tc.name,
                                        "arguments": serde_json::to_string(&tc.arguments).unwrap_or_default()
                                    }
                                }));
                            }

                            api_messages.push(serde_json::json!({
                                "role": "assistant",
                                "content": msg.content,
                                "tool_calls": openai_tool_calls
                            }));
                        }
                    } else {
                        // Simple assistant message with text only
                        api_messages.push(serde_json::json!({
                            "role": "assistant",
                            "content": msg.content
                        }));
                    }
                }
                crate::types::MessageRole::Tool => {
                    // Tool result message
                    let tool_use_id = msg.tool_call_id.clone().unwrap_or_default();

                    // Build content for tool result
                    let content = if msg.is_error == Some(true) {
                        format!("<tool_use_error>{}</tool_use_error>", msg.content)
                    } else {
                        msg.content.clone()
                    };

                    // OpenAI-compatible API expects plain text content for tool results
                    // Anthropic API expects structured tool_result blocks
                    // We check if this is Anthropic or OpenAI based on base_url (checked at call site)
                    // For now, use the simple text format for OpenAI
                    api_messages.push(serde_json::json!({
                        "role": "tool",
                        "content": content,
                        "tool_call_id": tool_use_id
                    }));
                }
                crate::types::MessageRole::System => {
                    // System messages - include as user message per Anthropic
                    api_messages.push(serde_json::json!({
                        "role": "user",
                        "content": msg.content
                    }));
                }
            }
        }
        Ok(api_messages)
    }
}

/// Calculate which messages to keep during compaction
/// Keeps first few messages (system prompt context) and recent messages
/// This is a simplified version - TypeScript uses LLM to create a summary
fn calculate_compaction_messages(
    messages: &[crate::types::Message],
    target_tokens: u32,
) -> Vec<crate::types::Message> {
    if messages.len() <= 4 {
        // Not enough messages to need compaction
        return messages.to_vec();
    }

    // Estimate tokens per message (rough average)
    let avg_tokens_per_msg = 500;
    let target_message_count = (target_tokens / avg_tokens_per_msg).max(10) as usize;

    // Always keep at least first 2 messages (system + initial context)
    // Keep more recent messages to preserve conversation context
    let keep_first = 2;
    let keep_last = target_message_count.saturating_sub(keep_first);

    if messages.len() <= keep_first + keep_last {
        return messages.to_vec();
    }

    let first_part = &messages[..keep_first];
    let last_part = &messages[messages.len() - keep_last..];

    let mut result = Vec::with_capacity(keep_first + keep_last);
    result.extend(first_part.iter().cloned());
    result.extend(last_part.iter().cloned());
    result
}

/// Extract text from API response (supports both Anthropic and OpenAI formats)
fn extract_text_from_response(response: &serde_json::Value) -> String {
    // Try OpenAI format first: response.choices[].message.content
    if let Some(choices) = response.get("choices").and_then(|c| c.as_array()) {
        if let Some(first_choice) = choices.first() {
            if let Some(content) = first_choice.get("message").and_then(|m| m.get("content")) {
                if let Some(text) = content.as_str() {
                    return text.to_string();
                }
            }
        }
    }

    // Try Anthropic format: response.content[].text
    if let Some(content) = response.get("content").and_then(|c| c.as_array()) {
        for block in content {
            if let Some(text) = block.get("text").and_then(|t| t.as_str()) {
                return text.to_string();
            }
        }
    }

    String::new()
}

/// Parse the compact summary to extract <summary> content
/// Strips the <analysis> block as it's just a drafting scratchpad
fn parse_compact_summary(raw_summary: &str) -> String {
    // Extract <summary> content
    if let Some(start) = raw_summary.find("<summary>") {
        if let Some(end) = raw_summary.find("</summary>") {
            let mut summary = raw_summary[start + 9..end].trim().to_string();

            // Also look for any content after </summary> that might be part of summary
            if let Some(after) = raw_summary.find("</summary>") {
                let remaining = raw_summary[after + 11..].trim();
                if !remaining.is_empty() && !remaining.starts_with('<') {
                    summary.push_str("\n\n");
                    summary.push_str(remaining);
                }
            }

            // If no <summary> tag found, use the whole response as summary
            return if summary.is_empty() {
                raw_summary.trim().to_string()
            } else {
                summary
            };
        }
    }

    // If no <summary> tags, try to find and remove <analysis> section
    let mut cleaned = raw_summary.to_string();
    if let Some(analysis_start) = cleaned.find("<analysis>") {
        if let Some(analysis_end) = cleaned.find("</analysis>") {
            cleaned = format!(
                "{}{}",
                &cleaned[..analysis_start],
                cleaned[analysis_end + 11..].trim()
            );
        }
    }

    cleaned.trim().to_string()
}

fn extract_tool_calls(response: &serde_json::Value) -> Vec<serde_json::Value> {
    // First try OpenAI format: response.choices[].message.tool_calls
    if let Some(choices) = response.get("choices").and_then(|c| c.as_array()) {
        if let Some(first_choice) = choices.first() {
            if let Some(message) = first_choice.get("message") {
                if let Some(tool_calls) = message.get("tool_calls").and_then(|t| t.as_array()) {
                    if !tool_calls.is_empty() {
                        return tool_calls
                            .iter()
                            .map(|tc| {
                                let func = tc.get("function");
                                let name = func
                                    .and_then(|f| f.get("name"))
                                    .cloned()
                                    .unwrap_or(serde_json::Value::Null);
                                // Handle arguments - could be string or object
                                let args = func.and_then(|f| f.get("arguments"));
                                let arguments = if let Some(args_val) = args {
                                    if let Some(arg_str) = args_val.as_str() {
                                        // Parse JSON string to object
                                        serde_json::from_str(arg_str).unwrap_or(args_val.clone())
                                    } else {
                                        args_val.clone()
                                    }
                                } else {
                                    serde_json::Value::Null
                                };
                                // Get tool_call_id from the tc object directly
                                let id = tc.get("id").cloned();
                                let mut result = serde_json::json!({
                                    "name": name,
                                    "arguments": arguments,
                                });
                                if let Some(id_val) = id {
                                    result["id"] = id_val;
                                }
                                result
                            })
                            .collect();
                    }
                }
            }
        }
    }

    vec![]
}
/// Format: \n<minimax:tool_call>\n<invoke name="tool-name">\n<parameter name="key">value

fn extract_response_text(response: &serde_json::Value) -> String {
    // OpenAI chat completions format
    if let Some(choices) = response.get("choices").and_then(|c| c.as_array()) {
        if let Some(first_choice) = choices.first() {
            if let Some(message) = first_choice.get("message") {
                if let Some(content) = message.get("content").and_then(|c| c.as_str()) {
                    return content.to_string();
                }
            }
        }
    }

    // Fallback: check for Anthropic format
    if let Some(content) = response.get("content").and_then(|c| c.as_array()) {
        for block in content {
            if let Some(block_type) = block.get("type").and_then(|t| t.as_str()) {
                match block_type {
                    "text" => {
                        if let Some(t) = block.get("text").and_then(|t| t.as_str()) {
                            return t.to_string();
                        }
                    }
                    _ => {}
                }
            }
        }
    }

    String::new()
}

fn extract_usage(response: &serde_json::Value) -> TokenUsage {
    // OpenAI format: response.usage
    if let Some(usage) = response.get("usage") {
        return TokenUsage {
            input_tokens: usage
                .get("prompt_tokens")
                .and_then(|v| v.as_u64())
                .unwrap_or(0)
                + usage
                    .get("completion_tokens")
                    .and_then(|v| v.as_u64())
                    .unwrap_or(0),
            output_tokens: usage
                .get("completion_tokens")
                .and_then(|v| v.as_u64())
                .unwrap_or(0),
            cache_creation_input_tokens: None,
            cache_read_input_tokens: None,
        };
    }

    // Fallback: Anthropic format
    let usage = response.get("usage");
    TokenUsage {
        input_tokens: usage
            .and_then(|u| u.get("input_tokens"))
            .and_then(|v| v.as_u64())
            .unwrap_or(0),
        output_tokens: usage
            .and_then(|u| u.get("output_tokens"))
            .and_then(|v| v.as_u64())
            .unwrap_or(0),
        cache_creation_input_tokens: usage
            .and_then(|u| u.get("cache_creation_input_tokens"))
            .and_then(|v| v.as_u64()),
        cache_read_input_tokens: usage
            .and_then(|u| u.get("cache_read_input_tokens"))
            .and_then(|v| v.as_u64()),
    }
}

/// Streaming result containing accumulated content and tool calls
#[derive(Debug, Default)]
struct StreamingResult {
    content: String,
    tool_calls: Vec<serde_json::Value>,
    usage: TokenUsage,
}

/// Make non-streaming API request (fallback when streaming fails)
/// Matches TypeScript's executeNonStreamingRequest behavior
async fn make_nonstreaming_request(
    client: &reqwest::Client,
    url: &str,
    api_key: &str,
    mut request_body: serde_json::Value,
    on_event: Option<Arc<dyn Fn(AgentEvent) + Send + Sync>>,
) -> Result<StreamingResult, AgentError> {
    // Disable streaming for non-streaming request
    request_body["stream"] = serde_json::json!(false);

    // Determine if this is Anthropic API or a third-party API (OpenAI-compatible)
    let is_anthropic = url.contains("anthropic.com");

    let response = if is_anthropic {
        // Anthropic format
        client
            .post(url)
            .header("x-api-key", api_key)
            .header("anthropic-version", "2023-06-01")
            .header("Content-Type", "application/json")
            .json(&request_body)
            .send()
            .await
            .map_err(|e| AgentError::Api(format!("Non-streaming request failed: {}", e)))?
    } else {
        // OpenAI-compatible format (vLLM, etc.) - use Bearer auth
        client
            .post(url)
            .header("Authorization", format!("Bearer {}", api_key))
            .header("Content-Type", "application/json")
            .json(&request_body)
            .send()
            .await
            .map_err(|e| AgentError::Api(format!("Non-streaming request failed: {}", e)))?
    };

    let status = response.status();
    if !status.is_success() {
        let error_text = response.text().await.unwrap_or_default();
        return Err(AgentError::Api(format!(
            "Non-streaming API error {}: {}",
            status, error_text
        )));
    }

    // Emit MessageStart event
    if let Some(ref cb) = on_event {
        cb(AgentEvent::MessageStart {
            message_id: uuid::Uuid::new_v4().to_string(),
        });
    }

    // Get response body
    let response_text = response
        .text()
        .await
        .map_err(|e| AgentError::Api(format!("Failed to read non-streaming response: {}", e)))?;

    // Parse JSON response
    let response_json: serde_json::Value =
        serde_json::from_str(&response_text).map_err(|e| {
            AgentError::Api(format!(
                "Failed to parse non-streaming response: {} - {}",
                e, response_text
            ))
        })?;

    // Check for API error
    if let Some(error) = response_json.get("error") {
        return Err(AgentError::Api(format!("API error: {}", error)));
    }

    let mut result = StreamingResult::default();

    // Handle Anthropic format: response.content[] with blocks
    if let Some(content) = response_json.get("content").and_then(|c| c.as_array()) {
        for block in content {
            let block_type = block.get("type").and_then(|t| t.as_str());
            match block_type {
                Some("text") => {
                    if let Some(text) = block.get("text").and_then(|t| t.as_str()) {
                        result.content.push_str(text);
                    }
                }
                Some("tool_use") => {
                    let tool_id = block.get("id").and_then(|i| i.as_str()).unwrap_or("");
                    let tool_name = block.get("name").and_then(|n| n.as_str()).unwrap_or("");
                    let tool_input = block.get("input").cloned().unwrap_or(serde_json::Value::Null);

                    result.tool_calls.push(serde_json::json!({
                        "id": tool_id,
                        "name": tool_name,
                        "arguments": tool_input,
                    }));
                }
                _ => {}
            }
        }
        // Extract usage
        if let Some(usage) = response_json.get("usage") {
            result.usage = parse_anthropic_usage(usage);
        }
    }
    // Handle OpenAI format: response.choices[].message
    else if let Some(choices) = response_json.get("choices").and_then(|c| c.as_array()) {
        if let Some(first_choice) = choices.first() {
            if let Some(message) = first_choice.get("message") {
                // Extract content
                if let Some(content) = message.get("content").and_then(|c| c.as_str()) {
                    result.content = content.to_string();
                }
                // Extract tool calls
                if let Some(tool_calls) = message.get("tool_calls").and_then(|t| t.as_array()) {
                    for tc in tool_calls {
                        let id = tc.get("id").and_then(|i| i.as_str()).unwrap_or("");
                        let func = tc.get("function");
                        let name = func
                            .and_then(|f| f.get("name"))
                            .and_then(|n| n.as_str())
                            .unwrap_or("");
                        let args = func.and_then(|f| f.get("arguments"));
                        let args_val = if let Some(args_str) = args.and_then(|a| a.as_str()) {
                            serde_json::from_str(args_str).unwrap_or(serde_json::Value::Null)
                        } else {
                            args.cloned().unwrap_or(serde_json::Value::Null)
                        };
                        result.tool_calls.push(serde_json::json!({
                            "id": id,
                            "name": name,
                            "arguments": args_val,
                        }));
                    }
                }
            }
        }
        // Extract usage (OpenAI format)
        if let Some(usage) = response_json.get("usage") {
            result.usage = TokenUsage {
                input_tokens: usage
                    .get("prompt_tokens")
                    .and_then(|v| v.as_u64())
                    .unwrap_or(0),
                output_tokens: usage
                    .get("completion_tokens")
                    .and_then(|v| v.as_u64())
                    .unwrap_or(0),
                cache_creation_input_tokens: None,
                cache_read_input_tokens: None,
            };
        }
    }

    // Emit completion events
    if let Some(ref cb) = on_event {
        cb(AgentEvent::ContentBlockStart {
            index: 0,
            block_type: "text".to_string(),
        });
        if !result.content.is_empty() {
            cb(AgentEvent::ContentBlockDelta {
                index: 0,
                delta: ContentDelta::Text {
                    text: result.content.clone(),
                },
            });
        }
        cb(AgentEvent::ContentBlockStop { index: 0 });
        cb(AgentEvent::MessageStop);
    }

    Ok(result)
}

/// Make streaming API call and process SSE events
/// Matches TypeScript query.ts behavior for streaming
async fn make_anthropic_streaming_request(
    client: &reqwest::Client,
    url: &str,
    api_key: &str,
    request_body: serde_json::Value,
    on_event: Option<Arc<dyn Fn(AgentEvent) + Send + Sync>>,
) -> Result<StreamingResult, AgentError> {
    use futures_util::stream::StreamExt;

    // Determine if this is Anthropic API or a third-party API (OpenAI-compatible)
    let is_anthropic = url.contains("anthropic.com");

    let response = if is_anthropic {
        // Anthropic format
        client
            .post(url)
            .header("x-api-key", api_key)
            .header("anthropic-version", "2023-06-01")
            .header("Content-Type", "application/json")
            .header("Accept", "text/event-stream")
            .json(&request_body)
            .send()
            .await
            .map_err(|e| AgentError::Api(format!("Streaming request failed: {}", e)))?
    } else {
        // OpenAI-compatible format (vLLM, etc.) - use Bearer auth
        client
            .post(url)
            .header("Authorization", format!("Bearer {}", api_key))
            .header("Content-Type", "application/json")
            .header("Accept", "text/event-stream")
            .json(&request_body)
            .send()
            .await
            .map_err(|e| AgentError::Api(format!("Streaming request failed: {}", e)))?
    };

    let status = response.status();
    if !status.is_success() {
        let error_text = response.text().await.unwrap_or_default();
        return Err(AgentError::Api(format!(
            "Streaming API error {}: {}",
            status, error_text
        )));
    }

    // Emit MessageStart event
    if let Some(ref cb) = on_event {
        cb(AgentEvent::MessageStart {
            message_id: uuid::Uuid::new_v4().to_string(),
        });
    }

    // Get the streaming body
    let body = response.bytes_stream();
    let mut stream: futures_util::stream::BoxStream<'_, Result<bytes::Bytes, reqwest::Error>> =
        Box::pin(body);

    let mut result = StreamingResult::default();
    let mut current_tool_use: Option<(String, String, String)> = None; // (id, name, args_str)
    let mut content_index: u32 = 0;
    let mut tool_use_index: u32 = 0;
    let mut in_tool_use = false;
    let mut text_block_started = false;

    // Process stream chunks
    while let Some(chunk_result) = stream.next().await {
        let chunk =
            chunk_result.map_err(|e| AgentError::Api(format!("Stream read error: {}", e)))?;

        // Parse the chunk as text
        if let Ok(text) = String::from_utf8(chunk.to_vec()) {
            // Check if this is SSE format (starts with "data: ")
            if !text.starts_with("data: ") {
                // Not SSE format - might be complete JSON response or vLLM streaming
                // Try parsing as complete JSON
                if let Ok(json) = serde_json::from_str::<serde_json::Value>(&text) {
                    // Check for vLLM streaming format: has "content" at top level (not in choices)
                    // This is different from standard OpenAI which uses choices[].delta.content
                    if json.get("content").is_some() && json.get("choices").is_none() {
                        // Check if this is a complete non-streaming response (has content array)
                        if let Some(content_array) = json.get("content").and_then(|c| c.as_array())
                        {
                            for block in content_array {
                                let block_type = block.get("type").and_then(|t| t.as_str());
                                match block_type {
                                    Some("text") => {
                                        if let Some(text) =
                                            block.get("text").and_then(|t| t.as_str())
                                        {
                                            result.content.push_str(text);
                                        }
                                    }
                                    Some("tool_use") => {
                                        let tool_id =
                                            block.get("id").and_then(|i| i.as_str()).unwrap_or("");
                                        let tool_name = block
                                            .get("name")
                                            .and_then(|n| n.as_str())
                                            .unwrap_or("");
                                        let tool_input = block
                                            .get("input")
                                            .cloned()
                                            .unwrap_or(serde_json::Value::Null);
                                        result.tool_calls.push(serde_json::json!({
                                            "id": tool_id,
                                            "name": tool_name,
                                            "arguments": tool_input,
                                        }));
                                    }
                                    _ => {}
                                }
                            }
                            // Extract usage if present
                            if let Some(usage) = json.get("usage") {
                                result.usage = parse_anthropic_usage(usage);
                            }
                            // Emit events and return complete response
                            if let Some(ref cb) = on_event {
                                cb(AgentEvent::MessageStart {
                                    message_id: json
                                        .get("id")
                                        .and_then(|i| i.as_str())
                                        .unwrap_or("")
                                        .to_string(),
                                });
                                cb(AgentEvent::ContentBlockStart {
                                    index: 0,
                                    block_type: "text".to_string(),
                                });
                                if !result.content.is_empty() {
                                    cb(AgentEvent::ContentBlockDelta {
                                        index: 0,
                                        delta: ContentDelta::Text {
                                            text: result.content.clone(),
                                        },
                                    });
                                }
                                cb(AgentEvent::ContentBlockStop { index: 0 });
                                cb(AgentEvent::MessageStop);
                            }
                            return Ok(result);
                        }
                        // vLLM streaming chunk - accumulate content
                        if let Some(content) = json.get("content").and_then(|c| c.as_str()) {
                            result.content.push_str(content);
                        }
                        // Check for stop reason (not null) to know when to finish
                        if let Some(stop_reason) = json.get("stop_reason") {
                            if !stop_reason.is_null() {
                                if let Some(ref cb) = on_event {
                                    cb(AgentEvent::ContentBlockStart {
                                        index: 0,
                                        block_type: "text".to_string(),
                                    });
                                    if !result.content.is_empty() {
                                        cb(AgentEvent::ContentBlockDelta {
                                            index: 0,
                                            delta: ContentDelta::Text {
                                                text: result.content.clone(),
                                            },
                                        });
                                    }
                                    cb(AgentEvent::ContentBlockStop { index: 0 });
                                    cb(AgentEvent::MessageStop);
                                }
                                return Ok(result);
                            }
                        }
                        continue;
                    }

                    // Check for standard OpenAI streaming format: choices[0].delta.content
                    if let Some(choices) = json.get("choices").and_then(|c| c.as_array()) {
                        if let Some(first) = choices.first() {
                            if let Some(delta) = first.get("delta") {
                                // Extract text content
                                if let Some(content) = delta.get("content").and_then(|c| c.as_str())
                                {
                                    result.content.push_str(content);
                                }
                                // Extract tool calls from delta (streaming tool calls)
                                if let Some(tool_calls) = delta.get("tool_calls").and_then(|t| t.as_array()) {
                                    for tc in tool_calls {
                                        let id = tc.get("id").and_then(|i| i.as_str()).unwrap_or("");
                                        let func = tc.get("function");
                                        let name = func.and_then(|f| f.get("name")).and_then(|n| n.as_str()).unwrap_or("");
                                        let args = func.and_then(|f| f.get("arguments"));
                                        let args_val = if let Some(args_str) = args.and_then(|a| a.as_str()) {
                                            serde_json::from_str(args_str).unwrap_or(serde_json::Value::Null)
                                        } else {
                                            args.cloned().unwrap_or(serde_json::Value::Null)
                                        };
                                        // Add to result tool_calls
                                        result.tool_calls.push(serde_json::json!({
                                            "id": id,
                                            "name": name,
                                            "arguments": args_val,
                                        }));
                                    }
                                }
                            }
                            // Check for finish_reason to know when to stop
                            // Return if we have content OR tool_calls (model might output thinking only)
                            if let Some(finish_reason) =
                                first.get("finish_reason").and_then(|f| f.as_str())
                            {
                                if !finish_reason.is_empty()
                                    && finish_reason != "null"
                                    && (!result.content.is_empty() || !result.tool_calls.is_empty())
                                {
                                    if let Some(ref cb) = on_event {
                                        cb(AgentEvent::ContentBlockStop { index: 0 });
                                        cb(AgentEvent::MessageStop);
                                    }
                                    return Ok(result);
                                }
                            }
                        }
                        continue;
                    }

                    // Check if this is a complete non-streaming response (standard OpenAI format)
                    if json.get("choices").is_some() {
                        // This is a complete non-streaming response
                        // Extract content and tool calls
                        if let Some(choices) = json.get("choices").and_then(|c| c.as_array()) {
                            if let Some(first) = choices.first() {
                                if let Some(msg) = first.get("message") {
                                    // Extract content
                                    if let Some(content) =
                                        msg.get("content").and_then(|c| c.as_str())
                                    {
                                        result.content = content.to_string();
                                    }
                                    // Extract tool calls (for non-streaming fallback)
                                    if let Some(tool_calls) =
                                        msg.get("tool_calls").and_then(|t| t.as_array())
                                    {
                                        for tc in tool_calls {
                                            let id =
                                                tc.get("id").and_then(|i| i.as_str()).unwrap_or("");
                                            let func = tc.get("function");
                                            let name = func
                                                .and_then(|f| f.get("name"))
                                                .and_then(|n| n.as_str())
                                                .unwrap_or("");
                                            let args = func.and_then(|f| f.get("arguments"));
                                            let args_val = if let Some(args_str) =
                                                args.and_then(|a| a.as_str())
                                            {
                                                serde_json::from_str(args_str)
                                                    .unwrap_or(serde_json::Value::Null)
                                            } else {
                                                args.cloned().unwrap_or(serde_json::Value::Null)
                                            };
                                            result.tool_calls.push(serde_json::json!({
                                                "id": id,
                                                "name": name,
                                                "arguments": args_val,
                                            }));
                                        }
                                    }
                                }
                            }
                        }
                        // Extract usage
                        if let Some(usage) = json.get("usage") {
                            result.usage = TokenUsage {
                                input_tokens: usage
                                    .get("prompt_tokens")
                                    .and_then(|v| v.as_u64())
                                    .unwrap_or(0),
                                output_tokens: usage
                                    .get("completion_tokens")
                                    .and_then(|v| v.as_u64())
                                    .unwrap_or(0),
                                cache_creation_input_tokens: None,
                                cache_read_input_tokens: None,
                            };
                        }
                        // Emit message stop
                        if let Some(ref cb) = on_event {
                            cb(AgentEvent::ContentBlockStart {
                                index: 0,
                                block_type: "text".to_string(),
                            });
                            if !result.content.is_empty() {
                                cb(AgentEvent::ContentBlockDelta {
                                    index: 0,
                                    delta: ContentDelta::Text {
                                        text: result.content.clone(),
                                    },
                                });
                            }
                            cb(AgentEvent::ContentBlockStop { index: 0 });
                            cb(AgentEvent::MessageStop);
                        }
                        return Ok(result);
                    }
                }
                continue;
            }

            // Parse SSE format: "data: {...}\n\n"
            for line in text.lines() {
                if line.starts_with("data: ") {
                    let data = &line[6..];

                    // Skip [DONE] sentinel
                    if data == "[DONE]" {
                        continue;
                    }

                    // Parse JSON
                    if let Ok(json) = serde_json::from_str::<serde_json::Value>(data) {
                        // Handle Anthropic streaming format: check for event type
                        if let Some(event_type) = json.get("type").and_then(|t| t.as_str()) {
                            match event_type {
                                "message_start" => {
                                    // Message started - get usage if present
                                    if let Some(usage) = json.get("usage") {
                                        result.usage = parse_anthropic_usage(usage);
                                    }
                                }
                                "content_block_start" => {
                                    let index =
                                        json.get("index").and_then(|i| i.as_u64()).unwrap_or(0)
                                            as u32;
                                    let block_type = json
                                        .get("content_block")
                                        .and_then(|b| b.get("type"))
                                        .and_then(|t| t.as_str())
                                        .unwrap_or("text")
                                        .to_string();

                                    if block_type == "tool_use" {
                                        tool_use_index = index;
                                        in_tool_use = true;
                                        let tool_name = json
                                            .get("content_block")
                                            .and_then(|b| b.get("name"))
                                            .and_then(|n| n.as_str())
                                            .unwrap_or("")
                                            .to_string();
                                        let tool_id = json
                                            .get("content_block")
                                            .and_then(|b| b.get("id"))
                                            .and_then(|i| i.as_str())
                                            .unwrap_or("")
                                            .to_string();
                                        current_tool_use =
                                            Some((tool_id, tool_name, String::new()));
                                    } else {
                                        content_index = index;
                                        text_block_started = true;
                                    }

                                    if let Some(ref cb) = on_event {
                                        cb(AgentEvent::ContentBlockStart { index, block_type });
                                    }
                                }
                                "content_block_delta" => {
                                    let index =
                                        json.get("index").and_then(|i| i.as_u64()).unwrap_or(0)
                                            as u32;
                                    if let Some(delta) = json.get("delta") {
                                        let delta_type = delta.get("type").and_then(|t| t.as_str());

                                        match delta_type {
                                            Some("text_delta") => {
                                                if let Some(text) =
                                                    delta.get("text").and_then(|t| t.as_str())
                                                {
                                                    result.content.push_str(text);

                                                    if let Some(ref cb) = on_event {
                                                        cb(AgentEvent::ContentBlockDelta {
                                                            index,
                                                            delta: ContentDelta::Text {
                                                                text: text.to_string(),
                                                            },
                                                        });
                                                    }
                                                }
                                            }
                                            Some("input_json_delta") => {
                                                let partial_json = delta
                                                    .get("partial_json")
                                                    .and_then(|p| p.as_str())
                                                    .unwrap_or("");

                                                if let Some(ref mut current) = current_tool_use {
                                                    current.2.push_str(partial_json);
                                                }

                                                if let Some(ref cb) = on_event {
                                                    let tool_name = current_tool_use
                                                        .as_ref()
                                                        .map(|(_, n, _)| n.clone())
                                                        .unwrap_or_default();
                                                    let tool_id = current_tool_use
                                                        .as_ref()
                                                        .map(|(i, _, _)| i.clone())
                                                        .unwrap_or_default();
                                                    cb(AgentEvent::ContentBlockDelta {
                                                        index,
                                                        delta: ContentDelta::ToolUse {
                                                            id: tool_id,
                                                            name: tool_name,
                                                            input: serde_json::json!({ "partial": partial_json }),
                                                            is_complete: false,
                                                        },
                                                    });
                                                }
                                            }
                                            _ => {}
                                        }
                                    }
                                }
                                "content_block_stop" => {
                                    let index =
                                        json.get("index").and_then(|i| i.as_u64()).unwrap_or(0)
                                            as u32;

                                    // Check if this was a tool_use block
                                    if in_tool_use && index == tool_use_index {
                                        if let Some((id, name, args_str)) = current_tool_use.take()
                                        {
                                            let args: serde_json::Value =
                                                serde_json::from_str(&args_str)
                                                    .unwrap_or(serde_json::Value::Null);

                                            result.tool_calls.push(serde_json::json!({
                                                "id": id,
                                                "name": name,
                                                "arguments": args,
                                            }));
                                        }
                                        in_tool_use = false;
                                    }

                                    if let Some(ref cb) = on_event {
                                        cb(AgentEvent::ContentBlockStop { index });
                                    }
                                }
                                "message_delta" => {
                                    // Message delta - can contain usage info
                                    if let Some(usage) = json.get("usage") {
                                        result.usage = parse_anthropic_usage(usage);
                                    }
                                }
                                "message_stop" => {
                                    // Message complete
                                }
                                _ => {}
                            }
                        }

                        // Handle OpenAI streaming format in SSE: choices[0].delta.content
                        // This is different from non-SSE path (lines 1344-1367) which checks after vLLM
                        if let Some(choices) = json.get("choices").and_then(|c| c.as_array()) {
                            if let Some(first) = choices.first() {
                                if let Some(delta) = first.get("delta") {
                                    // Extract text content
                                    if let Some(content) =
                                        delta.get("content").and_then(|c| c.as_str())
                                    {
                                        if !content.is_empty() {
                                            result.content.push_str(content);

                                            if let Some(ref cb) = on_event {
                                                cb(AgentEvent::ContentBlockDelta {
                                                    index: 0,
                                                    delta: ContentDelta::Text {
                                                        text: content.to_string(),
                                                    },
                                                });
                                            }
                                        }
                                    }
                                    // Extract tool calls from delta (streaming tool calls)
                                    if let Some(tool_calls) =
                                        delta.get("tool_calls").and_then(|t| t.as_array())
                                    {
                                        for tc in tool_calls {
                                            let id = tc
                                                .get("id")
                                                .and_then(|i| i.as_str())
                                                .unwrap_or("");
                                            let func = tc.get("function");
                                            let name = func
                                                .and_then(|f| f.get("name"))
                                                .and_then(|n| n.as_str())
                                                .unwrap_or("");
                                            let args = func.and_then(|f| f.get("arguments"));
                                            let args_val =
                                                if let Some(args_str) = args.and_then(|a| a.as_str())
                                                {
                                                    serde_json::from_str(args_str)
                                                        .unwrap_or(serde_json::Value::Null)
                                                } else {
                                                    args.cloned()
                                                        .unwrap_or(serde_json::Value::Null)
                                                };
                                            result.tool_calls.push(serde_json::json!({
                                                "id": id,
                                                "name": name,
                                                "arguments": args_val,
                                            }));
                                        }
                                    }
                                }
                                // Check for finish_reason to know when to stop
                                if let Some(finish_reason) =
                                    first.get("finish_reason").and_then(|f| f.as_str())
                                {
                                    if !finish_reason.is_empty() && finish_reason != "null" {
                                        if let Some(ref cb) = on_event {
                                            cb(AgentEvent::ContentBlockStop { index: 0 });
                                            cb(AgentEvent::MessageStop);
                                        }
                                        return Ok(result);
                                    }
                                }
                            }
                            // Continue to get more chunks
                            continue;
                        }

                        // Also check for non-streaming response format (Anthropic)
                        if json.get("content").is_some() || json.get("id").is_some() {
                            // This is a complete non-streaming response
                            if let Some(content_array) =
                                json.get("content").and_then(|c| c.as_array())
                            {
                                for block in content_array {
                                    let block_type = block.get("type").and_then(|t| t.as_str());
                                    match block_type {
                                        Some("text") => {
                                            if let Some(text) =
                                                block.get("text").and_then(|t| t.as_str())
                                            {
                                                result.content.push_str(text);
                                            }
                                        }
                                        Some("tool_use") => {
                                            let tool_id = block
                                                .get("id")
                                                .and_then(|i| i.as_str())
                                                .unwrap_or("");
                                            let tool_name = block
                                                .get("name")
                                                .and_then(|n| n.as_str())
                                                .unwrap_or("");
                                            let tool_input = block
                                                .get("input")
                                                .cloned()
                                                .unwrap_or(serde_json::Value::Null);

                                            result.tool_calls.push(serde_json::json!({
                                                "id": tool_id,
                                                "name": tool_name,
                                                "arguments": tool_input,
                                            }));
                                        }
                                        _ => {}
                                    }
                                }
                            }

                            // Extract usage
                            if let Some(usage) = json.get("usage") {
                                result.usage = parse_anthropic_usage(usage);
                            }

                            // Emit events for complete response
                            if let Some(ref cb) = on_event {
                                cb(AgentEvent::ContentBlockStart {
                                    index: 0,
                                    block_type: "text".to_string(),
                                });
                                if !result.content.is_empty() {
                                    cb(AgentEvent::ContentBlockDelta {
                                        index: 0,
                                        delta: ContentDelta::Text {
                                            text: result.content.clone(),
                                        },
                                    });
                                }
                                cb(AgentEvent::ContentBlockStop { index: 0 });
                                cb(AgentEvent::MessageStop);
                            }
                            return Ok(result);
                        }
                    }
                }
            }
        }
    }

    // Emit MessageStop event
    if let Some(ref cb) = on_event {
        cb(AgentEvent::MessageStop);
    }

    Ok(result)
}

#[cfg(test)]
#[allow(unused_imports)]
mod tests {
    use super::*;

    #[tokio::test]
    async fn test_engine_creation() {
        let engine = QueryEngine::new(QueryEngineConfig {
            cwd: "/tmp".to_string(),
            model: "claude-sonnet-4-6".to_string(),
            api_key: None,
            base_url: None,
            tools: vec![],
            system_prompt: None,
            max_turns: 10,
            max_budget_usd: None,
            max_tokens: 16384,
            can_use_tool: None,
            on_event: None,
        });
        assert_eq!(engine.get_turn_count(), 0);
    }

    #[tokio::test]
    async fn test_engine_submit_message() {
        let mut engine = QueryEngine::new(QueryEngineConfig {
            cwd: "/tmp".to_string(),
            model: "claude-sonnet-4-6".to_string(),
            api_key: None,
            base_url: None,
            tools: vec![],
            system_prompt: None,
            max_turns: 10,
            max_budget_usd: None,
            max_tokens: 16384,
            can_use_tool: None,
            on_event: None,
        });

        let result = engine.submit_message("Hello").await;
        // Should fail because no API key
        assert!(result.is_err());
    }

    #[test]
    fn test_strip_thinking() {
        // Test stripping thinking tags from content
        let content =
            "<think>I should list the files here.</think>Here are the files: file1.txt, file2.txt";
        let result = strip_thinking(content);
        assert_eq!(result, "Here are the files: file1.txt, file2.txt");

        // Test content without thinking tags
        let content2 = "Hello world";
        let result2 = strip_thinking(content2);
        assert_eq!(result2, "Hello world");

        // Test content with only thinking tags
        let content3 = "<think>Thinking...</think>";
        let result3 = strip_thinking(content3);
        assert_eq!(result3, "");

        // Test multiple thinking blocks (no spaces between thinking and text in input)
        let content4 = "<think>First think</think>Hello<think>Second think</think>World";
        let result4 = strip_thinking(content4);
        assert_eq!(result4, "HelloWorld");
    }

    #[test]
    fn test_strip_thinking_utf8() {
        // Test UTF-8 multi-byte characters (arrow → is 3 bytes)
        let content = "<think>思考</think>Hello → World";
        let result = strip_thinking(content);
        assert_eq!(result, "Hello → World");

        // Test Chinese characters (each char is 3 bytes)
        let content2 = "<think>中文</think>你好世界";
        let result2 = strip_thinking(content2);
        assert_eq!(result2, "你好世界");

        // Test emoji (4 bytes each)
        let content3 = "<think>thinking emoji 🎭</think>Hello 👋 World";
        let result3 = strip_thinking(content3);
        assert_eq!(result3, "Hello 👋 World");

        // Test mixed content with UTF-8
        let content4 = "<think>The → symbol is here</think>Result: 你好 🎉";
        let result4 = strip_thinking(content4);
        assert_eq!(result4, "Result: 你好 🎉");

        // Test thinking at start with UTF-8
        let content5 = "<think>thinking开始啦</think>继续内容";
        let result5 = strip_thinking(content5);
        assert_eq!(result5, "继续内容");

        // Test thinking at end with UTF-8
        let content6 = "开始内容<think>thinking结束啦</think>";
        let result6 = strip_thinking(content6);
        assert_eq!(result6, "开始内容");

        // Test multiple UTF-8 thinking blocks
        let content7 = "<think>第一步思考→思考第二步</think>执行→完成";
        let result7 = strip_thinking(content7);
        assert_eq!(result7, "执行→完成");
    }

    #[test]
    fn test_fallback_tool_call_extraction() {
        // Test that fallback path extracts tool calls from non-streaming response
        use serde_json::json;

        // Simulate a non-streaming response with tool calls
        let response = json!({
            "choices": [
                {
                    "message": {
                        "content": null,
                        "tool_calls": [
                            {
                                "id": "call_123",
                                "type": "function",
                                "function": {
                                    "name": "Bash",
                                    "arguments": "{\"command\": \"ls -la\"}"
                                }
                            }
                        ]
                    },
                    "finish_reason": "tool_calls"
                }
            ],
            "usage": {
                "prompt_tokens": 100,
                "completion_tokens": 50
            }
        });

        // Extract tool calls like the fallback code does
        let mut tool_calls = Vec::new();
        if let Some(choices) = response.get("choices").and_then(|c| c.as_array()) {
            if let Some(first) = choices.first() {
                if let Some(msg) = first.get("message") {
                    if let Some(tc_array) = msg.get("tool_calls").and_then(|t| t.as_array()) {
                        for tc in tc_array {
                            let id = tc.get("id").and_then(|i| i.as_str()).unwrap_or("");
                            let func = tc.get("function");
                            let name = func
                                .and_then(|f| f.get("name"))
                                .and_then(|n| n.as_str())
                                .unwrap_or("");
                            let args = func.and_then(|f| f.get("arguments"));
                            let args_val = if let Some(args_str) = args.and_then(|a| a.as_str()) {
                                serde_json::from_str(args_str).unwrap_or(serde_json::Value::Null)
                            } else {
                                args.cloned().unwrap_or(serde_json::Value::Null)
                            };
                            tool_calls.push(serde_json::json!({
                                "id": id,
                                "name": name,
                                "arguments": args_val,
                            }));
                        }
                    }
                }
            }
        }

        assert_eq!(tool_calls.len(), 1);
        assert_eq!(tool_calls[0]["name"], "Bash");
        assert_eq!(tool_calls[0]["id"], "call_123");
    }

    #[test]
    fn test_streaming_tool_call_extraction() {
        // Test that streaming path can extract tool calls from SSE-like data
        use serde_json::json;

        // Simulate a streaming chunk with tool call delta
        let chunk = json!({
            "choices": [
                {
                    "delta": {
                        "tool_calls": [
                            {
                                "id": "call_456",
                                "type": "function",
                                "function": {
                                    "name": "Read",
                                    "arguments": "{\"file_path\": \"/tmp/test\"}"
                                }
                            }
                        ]
                    },
                    "finish_reason": "tool_calls"
                }
            ]
        });

        // Verify the chunk has tool_calls
        let tool_calls = chunk
            .get("choices")
            .and_then(|c| c.as_array())
            .and_then(|choices| choices.first())
            .and_then(|choice| choice.get("delta"))
            .and_then(|delta| delta.get("tool_calls"))
            .and_then(|tc| tc.as_array());

        assert!(tool_calls.is_some());
        let tc = tool_calls.unwrap().first().unwrap();
        assert_eq!(tc.get("id").and_then(|i| i.as_str()), Some("call_456"));
        assert_eq!(
            tc.get("function")
                .and_then(|f| f.get("name"))
                .and_then(|n| n.as_str()),
            Some("Read")
        );
    }

    // =========================================================================
    // Tool Calling Tests
    // =========================================================================

    #[test]
    fn test_tool_definition_serialization() {
        use crate::tools::get_all_base_tools;
        use serde_json::json;

        let tools = get_all_base_tools();
        assert!(!tools.is_empty());

        // Test that tools can be serialized to OpenAI function format
        for tool in &tools {
            let tool_json = json!({
                "type": "function",
                "function": {
                    "name": tool.name,
                    "description": tool.description,
                    "parameters": tool.input_schema
                }
            });

            // Verify all required fields exist
            assert!(tool_json.get("type").is_some());
            assert!(tool_json.get("function").is_some());
            let func = tool_json.get("function").unwrap();
            assert!(func.get("name").is_some());
            assert!(func.get("description").is_some());
            assert!(func.get("parameters").is_some());

            // Verify name is not empty
            let name = func.get("name").unwrap().as_str().unwrap();
            assert!(!name.is_empty());
        }
    }

    #[test]
    fn test_tool_call_parsing() {
        use crate::types::{Message, MessageRole, ToolCall};

        // Test parsing tool calls from message
        let tool_calls = vec![
            ToolCall {
                id: "call_abc123".to_string(),
                name: "Bash".to_string(),
                arguments: serde_json::json!({"command": "ls -la"}),
            },
            ToolCall {
                id: "call_def456".to_string(),
                name: "Read".to_string(),
                arguments: serde_json::json!({"path": "/tmp/test.txt"}),
            },
        ];

        // Verify tool call structure
        assert_eq!(tool_calls.len(), 2);
        assert_eq!(tool_calls[0].id, "call_abc123");
        assert_eq!(tool_calls[0].name, "Bash");
        assert_eq!(tool_calls[1].id, "call_def456");
        assert_eq!(tool_calls[1].name, "Read");
    }

    #[test]
    fn test_tool_result_message_format() {
        use crate::types::{Message, MessageRole};

        // Test that tool results can be created with tool_call_id
        let msg = Message {
            role: MessageRole::Tool,
            content: "file content here".to_string(),
            tool_call_id: Some("call_abc123".to_string()),
            is_error: Some(false),
            ..Default::default()
        };

        assert_eq!(msg.role, MessageRole::Tool);
        assert_eq!(msg.tool_call_id, Some("call_abc123".to_string()));
        assert_eq!(msg.is_error, Some(false));
    }

    #[test]
    fn test_tool_execution_context() {
        use crate::types::ToolContext;

        let ctx = ToolContext {
            cwd: "/tmp/test".to_string(),
            abort_signal: None,
        };

        assert_eq!(ctx.cwd, "/tmp/test");
    }

    #[test]
    fn test_base_tools_available() {
        use crate::tools::get_all_base_tools;

        let tools = get_all_base_tools();

        // Verify essential tools are available
        let tool_names: Vec<&str> = tools.iter().map(|t| t.name.as_str()).collect();

        // Must have Bash tool
        assert!(tool_names.contains(&"Bash"), "Bash tool must be available");

        // Must have Read tool
        assert!(
            tool_names.contains(&"FileRead"),
            "FileRead tool must be available"
        );

        // Must have Write tool
        assert!(
            tool_names.contains(&"FileWrite"),
            "FileWrite tool must be available"
        );

        // Must have Glob tool
        assert!(tool_names.contains(&"Glob"), "Glob tool must be available");

        // Must have Grep tool
        assert!(tool_names.contains(&"Grep"), "Grep tool must be available");

        // Must have Edit tool
        assert!(
            tool_names.contains(&"FileEdit"),
            "FileEdit tool must be available"
        );
    }

    #[test]
    fn test_tool_schemas_have_required_fields() {
        use crate::tools::get_all_base_tools;

        let tools = get_all_base_tools();

        for tool in &tools {
            // Name must not be empty
            assert!(!tool.name.is_empty(), "Tool {} has empty name", tool.name);

            // Description must not be empty
            assert!(
                !tool.description.is_empty(),
                "Tool {} has empty description",
                tool.name
            );

            // Input schema must have required fields
            let schema = &tool.input_schema;
            assert!(
                !schema.schema_type.is_empty(),
                "Tool {} has empty schema_type",
                tool.name
            );
            assert!(
                schema.properties.is_object(),
                "Tool {} has non-object properties",
                tool.name
            );
        }
    }

    #[test]
    fn test_tool_schema_has_required_parameters() {
        use crate::tools::get_all_base_tools;

        let tools = get_all_base_tools();

        // Find Bash tool and verify it has command parameter
        let bash_tool = tools.iter().find(|t| t.name == "Bash").unwrap();
        let props = &bash_tool.input_schema.properties;
        assert!(
            props.get("command").is_some(),
            "Bash tool must have 'command' parameter"
        );

        // Find Read tool and verify it has path parameter
        let read_tool = tools.iter().find(|t| t.name == "FileRead").unwrap();
        let read_props = &read_tool.input_schema.properties;
        assert!(
            read_props.get("path").is_some(),
            "FileRead tool must have 'path' parameter"
        );

        // Find Write tool and verify it has path and content parameters
        let write_tool = tools.iter().find(|t| t.name == "FileWrite").unwrap();
        let write_props = &write_tool.input_schema.properties;
        assert!(
            write_props.get("path").is_some(),
            "FileWrite tool must have 'path' parameter"
        );
        assert!(
            write_props.get("content").is_some(),
            "FileWrite tool must have 'content' parameter"
        );

        // Verify required arrays are defined
        assert!(
            bash_tool.input_schema.required.is_some(),
            "Bash tool must have required parameters"
        );
    }

    #[tokio::test]
    async fn test_engine_with_tools_config() {
        use crate::tools::get_all_base_tools;

        let tools = get_all_base_tools();

        let engine = QueryEngine::new(QueryEngineConfig {
            cwd: "/tmp".to_string(),
            model: "claude-sonnet-4-6".to_string(),
            api_key: None,
            base_url: None,
            tools: tools.clone(),
            system_prompt: Some("You are a helpful assistant.".to_string()),
            max_turns: 10,
            max_budget_usd: None,
            max_tokens: 16384,
            can_use_tool: None,
            on_event: None,
        });

        // Verify tools are stored in config
        assert!(!engine.config.tools.is_empty());
    }

    #[tokio::test]
    async fn test_engine_system_prompt_includes_tool_guidance() {
        // Test that system prompt includes tool usage guidance
        let engine = QueryEngine::new(QueryEngineConfig {
            cwd: "/tmp".to_string(),
            model: "claude-sonnet-4-6".to_string(),
            api_key: None,
            base_url: None,
            tools: vec![],
            system_prompt: Some("You are an agent that helps users with software engineering tasks. Use the tools available to you to assist the user.".to_string()),
            max_turns: 10,
            max_budget_usd: None,
            max_tokens: 16384,
            can_use_tool: None,
            on_event: None,
        });

        // Verify system prompt is set
        assert!(engine.config.system_prompt.is_some());
        let prompt = engine.config.system_prompt.as_ref().unwrap();
        assert!(prompt.contains("tools"));
    }

    #[test]
    fn test_tool_call_arguments_json() {
        use crate::types::ToolCall;

        // Test that tool call arguments can be serialized/deserialized as JSON
        let tc = ToolCall {
            id: "call_test".to_string(),
            name: "Bash".to_string(),
            arguments: serde_json::json!({
                "command": "echo hello"
            }),
        };

        // Serialize arguments to string
        let args_str = tc.arguments.to_string();
        assert!(!args_str.is_empty());

        // Deserialize back
        let parsed: serde_json::Value = serde_json::from_str(&args_str).unwrap();
        assert_eq!(
            parsed.get("command").and_then(|v| v.as_str()),
            Some("echo hello")
        );
    }

    #[test]
    fn test_build_api_messages_includes_tools_info() {
        // This test verifies that the system prompt structure supports tool calling
        let system_prompt = "You are an agent. Use the tools available to you: Bash, Read, Write, Glob, Grep, Edit.";

        // Verify the prompt mentions tools
        assert!(system_prompt.contains("tools"));
        assert!(system_prompt.contains("Bash"));
    }

    #[tokio::test]
    async fn test_query_engine_tool_registration() {
        use crate::tools::get_all_base_tools;

        let tools = get_all_base_tools();
        let tool_names: Vec<String> = tools.iter().map(|t| t.name.clone()).collect();

        // Verify we have multiple tools registered
        assert!(tool_names.len() >= 10, "Should have at least 10 tools");

        // Verify key tools exist
        assert!(tool_names.contains(&"Bash".to_string()));
        assert!(tool_names.contains(&"FileRead".to_string()));
        assert!(tool_names.contains(&"FileWrite".to_string()));
        assert!(tool_names.contains(&"Glob".to_string()));
        assert!(tool_names.contains(&"Grep".to_string()));
        assert!(tool_names.contains(&"FileEdit".to_string()));
    }

    #[test]
    fn test_openai_tool_format_compatibility() {
        use crate::tools::get_all_base_tools;
        use serde_json::json;

        // Test that tools serialize to OpenAI-compatible format
        let tools = get_all_base_tools();
        let bash_tool = tools.iter().find(|t| t.name == "Bash").unwrap();

        let openai_format = json!({
            "type": "function",
            "function": {
                "name": bash_tool.name,
                "description": bash_tool.description,
                "parameters": bash_tool.input_schema
            }
        });

        // Verify OpenAI format structure
        assert_eq!(openai_format.get("type").unwrap(), "function");
        let func = openai_format.get("function").unwrap();
        assert!(func.get("name").is_some());
        assert!(func.get("description").is_some());
        assert!(func.get("parameters").is_some());

        // Verify it can be serialized to JSON string
        let json_str = openai_format.to_string();
        assert!(!json_str.is_empty());

        // Verify it can be deserialized back
        let parsed: serde_json::Value = serde_json::from_str(&json_str).unwrap();
        assert_eq!(parsed.get("type").unwrap(), "function");
    }

    #[tokio::test]
    async fn test_engine_message_history_with_tool_calls() {
        use crate::types::{Message, MessageRole, ToolCall};

        let mut engine = QueryEngine::new(QueryEngineConfig {
            cwd: "/tmp".to_string(),
            model: "claude-sonnet-4-6".to_string(),
            api_key: None,
            base_url: None,
            tools: vec![],
            system_prompt: None,
            max_turns: 10,
            max_budget_usd: None,
            max_tokens: 16384,
            can_use_tool: None,
            on_event: None,
        });

        // Add user message
        engine.messages.push(Message {
            role: MessageRole::User,
            content: "List files in /tmp".to_string(),
            ..Default::default()
        });

        // Add assistant message with tool call
        engine.messages.push(Message {
            role: MessageRole::Assistant,
            content: "".to_string(),
            tool_calls: Some(vec![ToolCall {
                id: "call_123".to_string(),
                name: "Bash".to_string(),
                arguments: serde_json::json!({"command": "ls /tmp"}),
            }]),
            ..Default::default()
        });

        // Add tool result message
        engine.messages.push(Message {
            role: MessageRole::Tool,
            content: "file1.txt\nfile2.txt".to_string(),
            tool_call_id: Some("call_123".to_string()),
            ..Default::default()
        });

        // Verify message history
        assert_eq!(engine.messages.len(), 3);
        assert_eq!(engine.messages[1].role, MessageRole::Assistant);
        assert!(engine.messages[1].tool_calls.is_some());
        assert_eq!(engine.messages[2].role, MessageRole::Tool);
        assert_eq!(
            engine.messages[2].tool_call_id,
            Some("call_123".to_string())
        );
    }

    #[test]
    fn test_tool_result_error_handling() {
        use crate::types::{Message, MessageRole};

        // Test tool result with error
        let error_msg = Message {
            role: MessageRole::Tool,
            content: "Error: Permission denied".to_string(),
            tool_call_id: Some("call_err".to_string()),
            is_error: Some(true),
            ..Default::default()
        };

        assert_eq!(error_msg.is_error, Some(true));
        assert!(error_msg.content.contains("Error"));
    }
}