git_iris/agents/

iris.rs

//! Iris Agent - The unified AI agent for Git-Iris operations
//!
//! This agent can handle any Git workflow task through capability-based prompts
//! and multi-turn execution using Rig. One agent to rule them all! ✨

use anyhow::Result;
use rig::agent::{AgentBuilder, PromptResponse};
use rig::completion::CompletionModel;
use schemars::JsonSchema;
use serde::de::DeserializeOwned;
use serde::{Deserialize, Serialize};
use std::borrow::Cow;
use std::collections::HashMap;
use std::fmt;
use std::sync::OnceLock;

/// Macro to build a streaming agent for any provider.
///
/// All three providers (`OpenAI`, `Anthropic`, `Gemini`) share identical setup logic —
/// subagent creation, tool attachment, optional content update tools — differing
/// only in the provider builder function. This macro eliminates that duplication.
macro_rules! build_streaming_agent {
    ($self:expr, $builder_fn:path, $fast_model:expr, $api_key:expr, $subagent_timeout:expr, $subagent_max_turns:expr) => {{
        use crate::agents::debug_tool::DebugTool;

        // Build subagent
        let sub_builder = $builder_fn($fast_model, $api_key)?
            .name("analyze_subagent")
            .preamble("You are a specialized analysis sub-agent.");
        let sub_builder = $self.apply_completion_params(
            sub_builder,
            $fast_model,
            4096,
            CompletionProfile::Subagent,
        )?;
        let sub_agent = crate::attach_core_tools!(sub_builder).build();

        // Build main agent with tools
        let builder = $builder_fn(&$self.model, $api_key)?
            .preamble($self.preamble.as_deref().unwrap_or("You are Iris."));
        let builder = $self.apply_completion_params(
            builder,
            &$self.model,
            16384,
            CompletionProfile::MainAgent,
        )?;

        let builder = crate::attach_core_tools!(builder)
            .tool(DebugTool::new(GitRepoInfo))
            .tool(DebugTool::new($self.workspace.clone()))
            .tool(DebugTool::new(ParallelAnalyze::with_limits(
                &$self.provider,
                $fast_model,
                $subagent_timeout,
                $subagent_max_turns,
                $api_key,
                $self.current_provider_additional_params().cloned(),
            )?))
            .tool(sub_agent);

        // Conditionally attach content update tools for chat mode
        if let Some(sender) = &$self.content_update_sender {
            use crate::agents::tools::{UpdateCommitTool, UpdatePRTool, UpdateReviewTool};
            Ok(builder
                .tool(DebugTool::new(UpdateCommitTool::new(sender.clone())))
                .tool(DebugTool::new(UpdatePRTool::new(sender.clone())))
                .tool(DebugTool::new(UpdateReviewTool::new(sender.clone())))
                .build())
        } else {
            Ok(builder.build())
        }
    }};
}

// Embed capability TOML files at compile time so they're always available
const CAPABILITY_COMMIT: &str = include_str!("capabilities/commit.toml");
const CAPABILITY_PR: &str = include_str!("capabilities/pr.toml");
const CAPABILITY_REVIEW: &str = include_str!("capabilities/review.toml");
const CAPABILITY_CHANGELOG: &str = include_str!("capabilities/changelog.toml");
const CAPABILITY_RELEASE_NOTES: &str = include_str!("capabilities/release_notes.toml");
const CAPABILITY_CHAT: &str = include_str!("capabilities/chat.toml");
const CAPABILITY_SEMANTIC_BLAME: &str = include_str!("capabilities/semantic_blame.toml");
const CAPABILITY_VERIFY: &str = include_str!("capabilities/verify.toml");
static VERIFY_CAPABILITY_CONFIG: OnceLock<(String, String)> = OnceLock::new();

/// Default preamble for Iris agent
const DEFAULT_PREAMBLE: &str = "\
You are Iris, a helpful AI assistant specialized in Git operations and workflows.

You have access to Git tools, code analysis tools, and powerful sub-agent capabilities for handling large analyses.

**File Access Tools:**
- **file_read** - Read file contents directly. Use `start_line` and `num_lines` for large files.
- **project_docs** - Load a compact snapshot of README and agent instructions. Use targeted doc types for full docs when needed.
- **code_search** - Search for patterns across files. Use sparingly; prefer file_read for known files.
- **repo_map** - Build a compact ranked map of source files, definitions, imports, and changed-file signals.
- **git_show** - Inspect a historical commit's message, stat, and patch.
- **git_blame** - Get line-level history and recent commits touching a file.
- **static_analysis** - Run installed linters directly for review evidence.

**Sub-Agent Tools:**

1. **parallel_analyze** - Run multiple analysis tasks CONCURRENTLY with independent context windows
   - Best for: Large changesets (>500 lines or >20 files), batch commit analysis
   - Each task runs in its own subagent, preventing context overflow
   - Example: parallel_analyze({ \"tasks\": [\"Analyze auth/ changes for security\", \"Review db/ for performance\", \"Check api/ for breaking changes\"] })

2. **analyze_subagent** - Delegate a single focused task to a sub-agent
   - Best for: Deep dive on specific files or focused analysis

**Best Practices:**
- Use git_diff to get changes first - it includes file content
- Use file_read to read files directly instead of multiple code_search calls
- Use repo_map when you need repository structure or cross-file orientation before targeted reads
- Use git_show after git_log or git_blame when a historical commit's exact patch would clarify intent or regression risk
- Use git_blame when history, ownership, or prior intent would improve commit messages, PR descriptions, or semantic explanations
- Use static_analysis during code review when linter/typechecker findings would sharpen or de-noise the review
- Use project_docs when repository conventions or product framing matter; do not front-load docs if the diff already answers the question
- Use parallel_analyze for large changesets to avoid context overflow

**Voice and Tone (applies to all output):**

Write directly. Avoid the common LLM tells that make output read as AI slop:

- No em dashes (—). Use commas, colons, periods, or parentheses instead. Hyphens (-) in compound words are fine.
- No hedge phrases like \"it's worth noting\", \"it's important to remember\", \"ultimately\", \"at the end of the day\", \"in essence\".
- No filler intros or outros: \"I'd be happy to\", \"let me explain\", \"in conclusion\", \"overall\", \"to summarize\".
- No hype vocabulary: \"robust\", \"comprehensive\", \"seamless\", \"leverage\", \"delve into\", \"unlock\", \"elevate\", \"powerful\", \"cutting-edge\", \"game-changing\".
- No vague intensifiers (\"very\", \"really\", \"extremely\", \"quite\") and no tricolon padding (\"fast, reliable, and scalable\" when one adjective fits).
- No meta-commentary openers: don't start with \"This commit adds...\", \"This PR introduces...\", \"This change refactors...\". Start with the verb: \"Add...\", \"Refactor...\".
- No stacked emoji. One project-style emoji is plenty when the repo uses gitmoji; never combos like 🚀✨🎉.
- \"In order to\" → \"to\". Prefer plain words over Latinate or marketing alternatives.

If user instructions, presets, project-config, or repository conventions specify a different tone, follow those over these defaults. These rules are the floor, not a ceiling that overrides explicit user voice.";

fn streaming_response_instructions(capability: &str) -> &'static str {
    if capability == "chat" {
        "After using the available tools, respond in plain text.\n\
         Keep it concise and do not repeat full content that tools already updated."
    } else {
        "After using the available tools, respond with your analysis in markdown format.\n\
         Keep it clear, well-structured, and informative."
    }
}

use crate::agents::provider::{self, CompletionProfile, DynAgent};
use crate::agents::tools::{GitRepoInfo, ParallelAnalyze, Workspace};

/// Trait for streaming callback to handle real-time response processing
#[async_trait::async_trait]
pub trait StreamingCallback: Send + Sync {
    /// Called when a new chunk of text is received
    async fn on_chunk(
        &self,
        chunk: &str,
        tokens: Option<crate::agents::status::TokenMetrics>,
    ) -> Result<()>;

    /// Called when the response is complete
    async fn on_complete(
        &self,
        full_response: &str,
        final_tokens: crate::agents::status::TokenMetrics,
    ) -> Result<()>;

    /// Called when an error occurs
    async fn on_error(&self, error: &anyhow::Error) -> Result<()>;

    /// Called for status updates
    async fn on_status_update(&self, message: &str) -> Result<()>;
}

/// Unified response type that can hold any structured output
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum StructuredResponse {
    CommitMessage(crate::types::GeneratedMessage),
    PullRequest(crate::types::MarkdownPullRequest),
    Changelog(crate::types::MarkdownChangelog),
    ReleaseNotes(crate::types::MarkdownReleaseNotes),
    /// Structured code review with parseable findings
    Review(crate::types::Review),
    /// Semantic blame explanation (plain text)
    SemanticBlame(String),
    PlainText(String),
}

#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema, Default)]
struct Critique {
    #[serde(default)]
    requires_revision: bool,
    #[serde(default)]
    issues: Vec<CritiqueIssue>,
    #[serde(default)]
    revision_prompt: String,
    #[serde(default)]
    confidence: u8,
}

#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
struct CritiqueIssue {
    title: String,
    body: String,
    severity: CritiqueSeverity,
}

#[derive(Debug, Clone, Copy, Serialize, JsonSchema, PartialEq, Eq)]
#[serde(rename_all = "lowercase")]
enum CritiqueSeverity {
    Critical,
    High,
    Medium,
    Low,
}

impl CritiqueSeverity {
    fn from_model_value(value: &str) -> Self {
        match value.trim().to_lowercase().as_str() {
            "critical" => Self::Critical,
            "high" => Self::High,
            "low" => Self::Low,
            _ => Self::Medium,
        }
    }
}

impl<'de> Deserialize<'de> for CritiqueSeverity {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        let value = String::deserialize(deserializer)?;
        Ok(Self::from_model_value(&value))
    }
}

impl fmt::Display for CritiqueSeverity {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            Self::Critical => write!(f, "critical"),
            Self::High => write!(f, "high"),
            Self::Medium => write!(f, "medium"),
            Self::Low => write!(f, "low"),
        }
    }
}

impl fmt::Display for StructuredResponse {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            StructuredResponse::CommitMessage(msg) => {
                write!(f, "{}", crate::types::format_commit_message(msg))
            }
            StructuredResponse::PullRequest(pr) => {
                write!(f, "{}", pr.raw_content())
            }
            StructuredResponse::Changelog(cl) => {
                write!(f, "{}", cl.raw_content())
            }
            StructuredResponse::ReleaseNotes(rn) => {
                write!(f, "{}", rn.raw_content())
            }
            StructuredResponse::Review(review) => {
                write!(f, "{}", review.format())
            }
            StructuredResponse::SemanticBlame(explanation) => {
                write!(f, "{explanation}")
            }
            StructuredResponse::PlainText(text) => {
                write!(f, "{text}")
            }
        }
    }
}

/// Locate the first balanced `{ ... }` pair in `s`, returning `(start, end)` byte
/// offsets where `end` is exclusive. Returns `None` if no balanced pair exists.
///
/// The scanner is intentionally simple — it does not track string literals, so
/// braces embedded inside strings may still close an enclosing object. Callers
/// compensate by trying subsequent candidates when parsing fails.
fn find_balanced_braces(s: &str) -> Option<(usize, usize)> {
    let mut depth: i32 = 0;
    let mut start: Option<usize> = None;
    for (i, ch) in s.char_indices() {
        match ch {
            '{' => {
                if depth == 0 {
                    start = Some(i);
                }
                depth += 1;
            }
            '}' if depth > 0 => {
                depth -= 1;
                if depth == 0 {
                    return start.map(|s_idx| (s_idx, i + 1));
                }
            }
            _ => {}
        }
    }
    None
}

/// Extract JSON from a potentially verbose response that might contain explanations
fn extract_json_from_response(response: &str) -> Result<String> {
    use crate::agents::debug;

    debug::debug_section("JSON Extraction");

    let trimmed_response = response.trim();

    // First, try parsing the entire response as JSON (for well-behaved responses)
    if trimmed_response.starts_with('{')
        && serde_json::from_str::<serde_json::Value>(trimmed_response).is_ok()
    {
        debug::debug_context_management(
            "Response is pure JSON",
            &format!("{} characters", trimmed_response.len()),
        );
        return Ok(trimmed_response.to_string());
    }

    // Try to find JSON within markdown code blocks
    if let Some(start) = response.find("```json") {
        let content_start = start + "```json".len();
        // Find the closing ``` on its own line (to avoid matching ``` inside JSON strings)
        // First try with newline prefix to find standalone closing marker
        let json_end = if let Some(end) = response[content_start..].find("\n```") {
            // Found it with newline - the JSON ends before the newline
            end
        } else {
            // Fallback: try to find ``` at start of response section or end of string
            response[content_start..]
                .find("```")
                .unwrap_or(response.len() - content_start)
        };

        let json_content = &response[content_start..content_start + json_end];
        let trimmed = json_content.trim().to_string();

        debug::debug_context_management(
            "Found JSON in markdown code block",
            &format!("{} characters", trimmed.len()),
        );

        // Save extracted JSON for debugging
        if let Err(e) = debug::write_debug_artifact("iris_extracted.json", &trimmed) {
            debug::debug_warning(&format!("Failed to write extracted JSON: {}", e));
        }

        debug::debug_json_parse_attempt(&trimmed);
        return Ok(trimmed);
    }

    // Look for JSON objects by scanning for balanced `{ ... }` pairs.
    //
    // The response may contain several `{` characters that are NOT the real JSON
    // payload — for example `${{ github.ref_name }}` lifted verbatim from a diff,
    // or template placeholders the model echoes in its prose. We try each balanced
    // candidate in order and return the first one that parses. If every candidate
    // fails, we fall through with an error built from the last attempt.
    let mut last_error: Option<anyhow::Error> = None;
    let mut cursor = 0;
    while cursor < response.len() {
        let Some((rel_start, rel_end)) = find_balanced_braces(&response[cursor..]) else {
            break;
        };
        let start = cursor + rel_start;
        let end = cursor + rel_end;
        let json_content = &response[start..end];
        debug::debug_json_parse_attempt(json_content);

        let sanitized = sanitize_json_response(json_content);
        match serde_json::from_str::<serde_json::Value>(&sanitized) {
            Ok(_) => {
                debug::debug_context_management(
                    "Found valid JSON object",
                    &format!("{} characters", json_content.len()),
                );
                return Ok(sanitized.into_owned());
            }
            Err(e) => {
                debug::debug_json_parse_error(&format!(
                    "Candidate at offset {} is not valid JSON: {}",
                    start, e
                ));
                let preview = if json_content.len() > 200 {
                    format!("{}...", &json_content[..200])
                } else {
                    json_content.to_string()
                };
                last_error = Some(anyhow::anyhow!(
                    "Found JSON-like content but it's not valid JSON: {}\nPreview: {}",
                    e,
                    preview
                ));
                // Advance past the opening brace of this failed candidate so we
                // can try the next `{` in the response.
                cursor = start + 1;
            }
        }
    }

    if let Some(err) = last_error {
        return Err(err);
    }

    // If no JSON found, check if the response is raw markdown that we can wrap
    // This handles cases where the model returns markdown directly without JSON wrapper
    let trimmed = response.trim();
    if trimmed.starts_with('#') || trimmed.starts_with("##") {
        debug::debug_context_management(
            "Detected raw markdown response",
            "Wrapping in JSON structure",
        );
        // Escape the markdown content for JSON and wrap it
        let escaped_content = serde_json::to_string(trimmed)?;
        // escaped_content includes quotes, so we need to use it directly as the value
        let wrapped = format!(r#"{{"content": {}}}"#, escaped_content);
        debug::debug_json_parse_attempt(&wrapped);
        return Ok(wrapped);
    }

    // If no JSON found, return error
    debug::debug_json_parse_error("No valid JSON found in response");
    Err(anyhow::anyhow!("No valid JSON found in response"))
}

/// Some providers (Anthropic) occasionally send literal control characters like newlines
/// inside JSON strings, which violates strict JSON parsing rules. This helper sanitizes
/// those responses by escaping control characters only within string literals while
/// leaving the rest of the payload untouched.
fn sanitize_json_response(raw: &str) -> Cow<'_, str> {
    let mut needs_sanitization = false;
    let mut in_string = false;
    let mut escaped = false;

    for ch in raw.chars() {
        if in_string {
            if escaped {
                escaped = false;
                continue;
            }

            match ch {
                '\\' => escaped = true,
                '"' => in_string = false,
                '\n' | '\r' | '\t' => {
                    needs_sanitization = true;
                    break;
                }
                c if c.is_control() => {
                    needs_sanitization = true;
                    break;
                }
                _ => {}
            }
        } else if ch == '"' {
            in_string = true;
        }
    }

    if !needs_sanitization {
        return Cow::Borrowed(raw);
    }

    let mut sanitized = String::with_capacity(raw.len());
    in_string = false;
    escaped = false;

    for ch in raw.chars() {
        if in_string {
            if escaped {
                sanitized.push(ch);
                escaped = false;
                continue;
            }

            match ch {
                '\\' => {
                    sanitized.push('\\');
                    escaped = true;
                }
                '"' => {
                    sanitized.push('"');
                    in_string = false;
                }
                '\n' => sanitized.push_str("\\n"),
                '\r' => sanitized.push_str("\\r"),
                '\t' => sanitized.push_str("\\t"),
                c if c.is_control() => {
                    use std::fmt::Write as _;
                    let _ = write!(&mut sanitized, "\\u{:04X}", u32::from(c));
                }
                _ => sanitized.push(ch),
            }
        } else {
            sanitized.push(ch);
            if ch == '"' {
                in_string = true;
                escaped = false;
            }
        }
    }

    Cow::Owned(sanitized)
}

/// Parse JSON with schema validation and error recovery
///
/// This function attempts to parse JSON with the following strategy:
/// 1. Try direct parsing (fast path for well-formed responses)
/// 2. If that fails, use the output validator for recovery
/// 3. Log any warnings about recovered issues
fn parse_with_recovery<T>(json_str: &str) -> Result<T>
where
    T: JsonSchema + DeserializeOwned,
{
    use crate::agents::debug as agent_debug;
    use crate::agents::output_validator::validate_and_parse;

    let validation_result = validate_and_parse::<T>(json_str)?;

    // Log recovery warnings
    if validation_result.recovered {
        agent_debug::debug_context_management(
            "JSON recovery applied",
            &format!("{} issues fixed", validation_result.warnings.len()),
        );
        for warning in &validation_result.warnings {
            agent_debug::debug_warning(warning);
        }
    }

    validation_result
        .value
        .ok_or_else(|| anyhow::anyhow!("Failed to parse JSON even after recovery"))
}

/// The unified Iris agent that can handle any Git-Iris task
///
/// Note: This struct is Send + Sync safe - we don't store the client builder,
/// instead we create it fresh when needed. This allows the agent to be used
/// across async boundaries with `tokio::spawn`.
pub struct IrisAgent {
    provider: String,
    model: String,
    /// Fast model for subagents and simple tasks
    fast_model: Option<String>,
    /// Current capability/task being executed
    current_capability: Option<String>,
    /// Provider configuration
    provider_config: HashMap<String, String>,
    /// Custom preamble
    preamble: Option<String>,
    /// Configuration for features like gitmoji, presets, etc.
    config: Option<crate::config::Config>,
    /// Optional sender for content updates (used in Studio chat mode)
    content_update_sender: Option<crate::agents::tools::ContentUpdateSender>,
    /// Persistent workspace for notes and task tracking (shared across agent invocations)
    workspace: Workspace,
}

impl IrisAgent {
    /// Create a new Iris agent with the given provider and model
    ///
    /// # Errors
    ///
    /// Returns an error when the provider or model configuration is invalid.
    pub fn new(provider: &str, model: &str) -> Result<Self> {
        Ok(Self {
            provider: provider.to_string(),
            model: model.to_string(),
            fast_model: None,
            current_capability: None,
            provider_config: HashMap::new(),
            preamble: None,
            config: None,
            content_update_sender: None,
            workspace: Workspace::new(),
        })
    }

    /// Set the content update sender for Studio chat mode
    ///
    /// When set, the agent will have access to tools for updating
    /// commit messages, PR descriptions, and reviews.
    pub fn set_content_update_sender(&mut self, sender: crate::agents::tools::ContentUpdateSender) {
        self.content_update_sender = Some(sender);
    }

    /// Get the effective fast model (configured or same as main model)
    fn effective_fast_model(&self) -> &str {
        self.fast_model.as_deref().unwrap_or(&self.model)
    }

    /// Get the API key for the current provider from config
    fn get_api_key(&self) -> Option<&str> {
        provider::current_provider_config(self.config.as_ref(), &self.provider)
            .and_then(crate::providers::ProviderConfig::api_key_if_set)
    }

    fn current_provider(&self) -> Result<crate::providers::Provider> {
        provider::provider_from_name(&self.provider)
    }

    fn current_provider_additional_params(&self) -> Option<&HashMap<String, String>> {
        provider::current_provider_config(self.config.as_ref(), &self.provider)
            .map(|provider_config| &provider_config.additional_params)
    }

    /// Build the actual agent for execution
    ///
    /// Uses provider-specific builders (rig-core 0.27+) with enum dispatch for runtime
    /// provider selection. Each provider arm builds both the subagent and main agent
    /// with proper typing.
    #[allow(clippy::too_many_lines)]
    fn build_agent(&self) -> Result<DynAgent> {
        use crate::agents::debug_tool::DebugTool;

        let preamble = self.preamble.as_deref().unwrap_or(DEFAULT_PREAMBLE);
        let fast_model = self.effective_fast_model();
        let api_key = self.get_api_key();
        let subagent_timeout = self
            .config
            .as_ref()
            .map_or(120, |c| c.subagent_timeout_secs);
        let subagent_max_turns = self.config.as_ref().map_or(20, |c| c.subagent_max_turns);

        // Macro to build and configure subagent with core tools
        macro_rules! build_subagent {
            ($builder:expr) => {{
                let builder = $builder
                    .name("analyze_subagent")
                    .description("Delegate focused analysis tasks to a sub-agent with its own context window. Use for analyzing specific files, commits, or code sections independently. The sub-agent has access to Git tools (diff, log, status) and file analysis tools.")
                    .preamble("You are a specialized analysis sub-agent for Iris. Your job is to complete focused analysis tasks and return concise, actionable summaries.

Guidelines:
- Use the available tools to gather information
- Focus only on what's asked - don't expand scope
- Return a clear, structured summary of findings
- Highlight important issues, patterns, or insights
- Keep your response focused and concise")
                    ;
                let builder = self.apply_completion_params(
                    builder,
                    fast_model,
                    4096,
                    CompletionProfile::Subagent,
                )?;
                crate::attach_core_tools!(builder).build()
            }};
        }

        // Macro to attach main agent tools (excluding subagent which varies by type)
        macro_rules! attach_main_tools {
            ($builder:expr) => {{
                crate::attach_core_tools!($builder)
                    .tool(DebugTool::new(GitRepoInfo))
                    .tool(DebugTool::new(self.workspace.clone()))
                    .tool(DebugTool::new(ParallelAnalyze::with_limits(
                        &self.provider,
                        fast_model,
                        subagent_timeout,
                        subagent_max_turns,
                        api_key,
                        self.current_provider_additional_params().cloned(),
                    )?))
            }};
        }

        // Macro to optionally attach content update tools
        macro_rules! maybe_attach_update_tools {
            ($builder:expr) => {{
                if let Some(sender) = &self.content_update_sender {
                    use crate::agents::tools::{UpdateCommitTool, UpdatePRTool, UpdateReviewTool};
                    $builder
                        .tool(DebugTool::new(UpdateCommitTool::new(sender.clone())))
                        .tool(DebugTool::new(UpdatePRTool::new(sender.clone())))
                        .tool(DebugTool::new(UpdateReviewTool::new(sender.clone())))
                        .build()
                } else {
                    $builder.build()
                }
            }};
        }

        match self.provider.as_str() {
            "openai" => {
                // Build subagent
                let sub_agent = build_subagent!(provider::openai_builder(fast_model, api_key)?);

                // Build main agent
                let builder = provider::openai_builder(&self.model, api_key)?.preamble(preamble);
                let builder = self.apply_completion_params(
                    builder,
                    &self.model,
                    16384,
                    CompletionProfile::MainAgent,
                )?;
                let builder = attach_main_tools!(builder).tool(sub_agent);
                let agent = maybe_attach_update_tools!(builder);
                Ok(DynAgent::OpenAI(agent))
            }
            "anthropic" => {
                // Build subagent
                let sub_agent = build_subagent!(provider::anthropic_builder(fast_model, api_key)?);

                // Build main agent
                let builder = provider::anthropic_builder(&self.model, api_key)?.preamble(preamble);
                let builder = self.apply_completion_params(
                    builder,
                    &self.model,
                    16384,
                    CompletionProfile::MainAgent,
                )?;
                let builder = attach_main_tools!(builder).tool(sub_agent);
                let agent = maybe_attach_update_tools!(builder);
                Ok(DynAgent::Anthropic(agent))
            }
            "google" | "gemini" => {
                // Build subagent
                let sub_agent = build_subagent!(provider::gemini_builder(fast_model, api_key)?);

                // Build main agent
                let builder = provider::gemini_builder(&self.model, api_key)?.preamble(preamble);
                let builder = self.apply_completion_params(
                    builder,
                    &self.model,
                    16384,
                    CompletionProfile::MainAgent,
                )?;
                let builder = attach_main_tools!(builder).tool(sub_agent);
                let agent = maybe_attach_update_tools!(builder);
                Ok(DynAgent::Gemini(agent))
            }
            _ => Err(anyhow::anyhow!("Unsupported provider: {}", self.provider)),
        }
    }

    fn apply_completion_params<M>(
        &self,
        builder: AgentBuilder<M>,
        model: &str,
        max_tokens: u64,
        profile: CompletionProfile,
    ) -> Result<AgentBuilder<M>>
    where
        M: CompletionModel,
    {
        let provider = self.current_provider()?;
        Ok(provider::apply_completion_params(
            builder,
            provider,
            model,
            max_tokens,
            self.current_provider_additional_params(),
            profile,
        ))
    }

    /// Execute task using agent with tools and parse structured JSON response
    /// This is the core method that enables Iris to use tools and generate structured outputs
    async fn execute_with_agent<T>(&self, system_prompt: &str, user_prompt: &str) -> Result<T>
    where
        T: JsonSchema + for<'a> serde::Deserialize<'a> + serde::Serialize + Send + Sync + 'static,
    {
        use crate::agents::debug;
        use crate::agents::status::IrisPhase;
        use crate::messages::get_capability_message;
        use schemars::schema_for;

        let capability = self.current_capability().unwrap_or("commit");

        debug::debug_phase_change(&format!("AGENT EXECUTION: {}", std::any::type_name::<T>()));

        // Update status - building agent (capability-aware)
        let msg = get_capability_message(capability);
        crate::iris_status_dynamic!(IrisPhase::Planning, msg.text, 2, 4);

        // Build agent with all tools attached
        let agent = self.build_agent()?;
        debug::debug_context_management(
            "Agent built with tools",
            &format!(
                "Provider: {}, Model: {} (fast: {})",
                self.provider,
                self.model,
                self.effective_fast_model()
            ),
        );

        // Create JSON schema for the response type
        let schema = schema_for!(T);
        let schema_json = serde_json::to_string_pretty(&schema)?;
        debug::debug_context_management(
            "JSON schema created",
            &format!("Type: {}", std::any::type_name::<T>()),
        );

        // Enhanced prompt that instructs Iris to use tools and respond with JSON
        let full_prompt = format!(
            "{system_prompt}\n\n{user_prompt}\n\n\
            === CRITICAL: RESPONSE FORMAT ===\n\
            After using the available tools to gather necessary information, you MUST respond with ONLY a valid JSON object.\n\n\
            REQUIRED JSON SCHEMA:\n\
            {schema_json}\n\n\
            CRITICAL INSTRUCTIONS:\n\
            - Return ONLY the raw JSON object - nothing else\n\
            - NO explanations before the JSON\n\
            - NO explanations after the JSON\n\
            - NO markdown code blocks (just raw JSON)\n\
            - NO preamble text like 'Here is the JSON:' or 'Let me generate:'\n\
            - Start your response with {{ and end with }}\n\
            - The JSON must be complete and valid\n\n\
            Your entire response should be ONLY the JSON object."
        );

        debug::debug_llm_request(&full_prompt, Some(16384));

        // Update status - generation phase (capability-aware)
        let gen_msg = get_capability_message(capability);
        crate::iris_status_dynamic!(IrisPhase::Generation, gen_msg.text, 3, 4);

        // Prompt the agent with multi-turn support
        // Set multi_turn to allow the agent to call multiple tools (default is 0 = single-shot)
        // For complex tasks like PRs and release notes, Iris may need many tool calls to analyze all changes
        // The agent knows when to stop, so we give it plenty of room (50 rounds)
        let timer = debug::DebugTimer::start("Agent prompt execution");

        debug::debug_context_management(
            "LLM request",
            "Sending prompt to agent with multi_turn(50)",
        );
        let prompt_response: PromptResponse = agent.prompt_extended(&full_prompt, 50).await?;

        timer.finish();

        // Extract usage stats for debug output
        let usage = &prompt_response.usage;
        debug::debug_context_management(
            "Token usage",
            &format!(
                "input: {} | output: {} | total: {} | cache write: {} | cache read: {}",
                usage.input_tokens,
                usage.output_tokens,
                usage.total_tokens,
                usage.cache_creation_input_tokens,
                usage.cached_input_tokens,
            ),
        );

        let response = &prompt_response.output;
        #[allow(clippy::cast_possible_truncation, clippy::as_conversions)]
        let total_tokens_usize = usage.total_tokens as usize;
        debug::debug_llm_response(
            response,
            std::time::Duration::from_secs(0),
            Some(total_tokens_usize),
        );

        // Update status - synthesis phase
        crate::iris_status_dynamic!(
            IrisPhase::Synthesis,
            "✨ Iris is synthesizing results...",
            4,
            4
        );

        // Extract and parse JSON from the response
        let json_str = extract_json_from_response(response)?;
        let sanitized_json = sanitize_json_response(&json_str);
        let sanitized_ref = sanitized_json.as_ref();

        if matches!(sanitized_json, Cow::Borrowed(_)) {
            debug::debug_json_parse_attempt(sanitized_ref);
        } else {
            debug::debug_context_management(
                "Sanitized JSON response",
                &format!("{} → {} characters", json_str.len(), sanitized_ref.len()),
            );
            debug::debug_json_parse_attempt(sanitized_ref);
        }

        // Use the output validator for robust parsing with error recovery
        let result: T = parse_with_recovery(sanitized_ref)?;

        debug::debug_json_parse_success(std::any::type_name::<T>());

        // Update status - completed
        crate::iris_status_completed!();

        Ok(result)
    }

    /// Inject style instructions into the system prompt based on config and capability
    ///
    /// Key distinction:
    /// - Commits: preset controls format (conventional = no emojis)
    /// - Non-commits (PR, review, changelog, `release_notes`): `use_gitmoji` controls emojis
    fn inject_style_instructions(&self, system_prompt: &mut String, capability: &str) {
        let Some(config) = &self.config else {
            return;
        };

        let preset_name = config.get_effective_preset_name();
        let is_conventional = preset_name == "conventional";
        let is_default_mode = preset_name == "default" || preset_name.is_empty();
        let use_style_detection =
            capability == "commit" && is_default_mode && config.gitmoji_override.is_none();
        let commit_emoji = config.use_gitmoji && !is_conventional && !use_style_detection;
        let output_emoji = config.gitmoji_override.unwrap_or(config.use_gitmoji);

        Self::inject_instruction_preset(system_prompt, preset_name, is_default_mode);

        if capability == "commit" {
            Self::inject_commit_styling(system_prompt, commit_emoji, is_conventional);
        }

        Self::inject_markdown_output_styling(system_prompt, capability, output_emoji);
    }

    fn inject_instruction_preset(
        system_prompt: &mut String,
        preset_name: &str,
        is_default_mode: bool,
    ) {
        if preset_name.is_empty() || is_default_mode {
            return;
        }

        let library = crate::instruction_presets::get_instruction_preset_library();
        if let Some(preset) = library.get_preset(preset_name) {
            tracing::info!("📋 Injecting '{}' preset style instructions", preset_name);
            system_prompt.push_str("\n\n=== STYLE INSTRUCTIONS ===\n");
            system_prompt.push_str(&preset.instructions);
            system_prompt.push('\n');
        } else {
            tracing::warn!("⚠️ Preset '{}' not found in library", preset_name);
        }
    }

    fn inject_commit_styling(
        system_prompt: &mut String,
        commit_emoji: bool,
        is_conventional: bool,
    ) {
        if commit_emoji {
            system_prompt.push_str("\n\n=== GITMOJI INSTRUCTIONS ===\n");
            system_prompt.push_str("Set the 'emoji' field to a single relevant gitmoji. ");
            system_prompt.push_str(
                "DO NOT include the emoji in the 'message' or 'title' text - only set the 'emoji' field. ",
            );
            system_prompt.push_str("Choose the closest match from this compact guide:\n\n");
            system_prompt.push_str(&crate::gitmoji::get_gitmoji_prompt_guide());
            system_prompt.push_str("\n\nThe emoji should match the primary type of change.");
        } else if is_conventional {
            system_prompt.push_str("\n\n=== CONVENTIONAL COMMITS FORMAT ===\n");
            system_prompt.push_str("IMPORTANT: This uses Conventional Commits format. ");
            system_prompt.push_str("DO NOT include any emojis in the commit message or PR title. ");
            system_prompt.push_str("The 'emoji' field should be null.");
        }
    }

    fn inject_markdown_output_styling(
        system_prompt: &mut String,
        capability: &str,
        output_emoji: bool,
    ) {
        match (capability, output_emoji) {
            ("pr" | "review", true) => Self::inject_pr_review_emoji_styling(system_prompt),
            ("release_notes", true) => Self::inject_release_notes_emoji_styling(system_prompt),
            ("changelog", true) => Self::inject_changelog_emoji_styling(system_prompt),
            ("pr" | "review" | "release_notes" | "changelog", false) => {
                Self::inject_no_emoji_styling(system_prompt);
            }
            _ => {}
        }
    }

    fn inject_pr_review_emoji_styling(prompt: &mut String) {
        prompt.push_str("\n\n=== EMOJI STYLING ===\n");
        prompt.push_str("Use emojis to make the output visually scannable and engaging:\n");
        prompt.push_str("- H1 title: ONE gitmoji at the start (✨, 🐛, ♻️, etc.)\n");
        prompt.push_str("- Section headers: Add relevant emojis (🎯 What's New, ⚙️ How It Works, 📋 Commits, ⚠️ Breaking Changes)\n");
        prompt.push_str("- Commit list entries: Include gitmoji where appropriate\n");
        prompt.push_str("- Body text: Keep clean - no scattered emojis within prose\n\n");
        prompt.push_str(&crate::gitmoji::get_gitmoji_prompt_guide());
    }

    fn inject_release_notes_emoji_styling(prompt: &mut String) {
        prompt.push_str("\n\n=== EMOJI STYLING ===\n");
        prompt.push_str("Use at most one emoji per highlight/section title. No emojis in bullet descriptions, upgrade notes, or metrics. ");
        prompt.push_str("Pick from the approved gitmoji list (e.g., 🌟 Highlights, 🤖 Agents, 🔧 Tooling, 🐛 Fixes, ⚡ Performance). ");
        prompt.push_str("Never sprinkle emojis within sentences or JSON keys.\n\n");
        prompt.push_str(&crate::gitmoji::get_gitmoji_prompt_guide());
    }

    fn inject_changelog_emoji_styling(prompt: &mut String) {
        prompt.push_str("\n\n=== EMOJI STYLING ===\n");
        prompt.push_str("Section keys must remain plain text (Added/Changed/Deprecated/Removed/Fixed/Security). ");
        prompt.push_str(
            "You may include one emoji within a change description to reinforce meaning. ",
        );
        prompt.push_str(
            "Never add emojis to JSON keys, section names, metrics, or upgrade notes.\n\n",
        );
        prompt.push_str(&crate::gitmoji::get_gitmoji_prompt_guide());
    }

    fn inject_no_emoji_styling(prompt: &mut String) {
        prompt.push_str("\n\n=== NO EMOJI STYLING ===\n");
        prompt.push_str(
            "DO NOT include any emojis anywhere in the output. Keep all content plain text.",
        );
    }

    /// Execute a task with the given capability and user prompt
    ///
    /// This now automatically uses structured output based on the capability type
    ///
    /// # Errors
    ///
    /// Returns an error when capability loading, agent construction, or generation fails.
    pub async fn execute_task(
        &mut self,
        capability: &str,
        user_prompt: &str,
    ) -> Result<StructuredResponse> {
        use crate::agents::status::IrisPhase;
        use crate::messages::get_capability_message;

        // Show initializing status with a capability-specific message
        let waiting_msg = get_capability_message(capability);
        crate::iris_status_dynamic!(IrisPhase::Initializing, waiting_msg.text, 1, 4);

        // Load the capability config to get both prompt and output type
        let (mut system_prompt, output_type) = self.load_capability_config(capability)?;

        // Inject style instructions (presets, gitmoji, conventional commits)
        self.inject_style_instructions(&mut system_prompt, capability);

        // Set the current capability
        self.current_capability = Some(capability.to_string());

        // Update status - analyzing with agent
        crate::iris_status_dynamic!(
            IrisPhase::Analysis,
            "🔍 Iris is analyzing your changes...",
            2,
            4
        );

        let response = self
            .execute_output_type(&output_type, &system_prompt, user_prompt)
            .await?;

        self.verify_response_if_enabled(
            capability,
            &output_type,
            &system_prompt,
            user_prompt,
            response,
        )
        .await
    }

    async fn execute_output_type(
        &self,
        output_type: &str,
        system_prompt: &str,
        user_prompt: &str,
    ) -> Result<StructuredResponse> {
        match output_type {
            "GeneratedMessage" => {
                let response = self
                    .execute_with_agent::<crate::types::GeneratedMessage>(
                        system_prompt,
                        user_prompt,
                    )
                    .await?;
                Ok(StructuredResponse::CommitMessage(response))
            }
            "MarkdownPullRequest" => {
                let response = self
                    .execute_with_agent::<crate::types::MarkdownPullRequest>(
                        system_prompt,
                        user_prompt,
                    )
                    .await?;
                Ok(StructuredResponse::PullRequest(response))
            }
            "MarkdownChangelog" => {
                let response = self
                    .execute_with_agent::<crate::types::MarkdownChangelog>(
                        system_prompt,
                        user_prompt,
                    )
                    .await?;
                Ok(StructuredResponse::Changelog(response))
            }
            "MarkdownReleaseNotes" => {
                let response = self
                    .execute_with_agent::<crate::types::MarkdownReleaseNotes>(
                        system_prompt,
                        user_prompt,
                    )
                    .await?;
                Ok(StructuredResponse::ReleaseNotes(response))
            }
            "Review" => {
                let response = self
                    .execute_with_agent::<crate::types::Review>(system_prompt, user_prompt)
                    .await?;
                Ok(StructuredResponse::Review(response))
            }
            "SemanticBlame" => {
                let agent = self.build_agent()?;
                let full_prompt = format!("{system_prompt}\n\n{user_prompt}");
                let response = agent.prompt_multi_turn(&full_prompt, 10).await?;
                Ok(StructuredResponse::SemanticBlame(response))
            }
            _ => {
                let agent = self.build_agent()?;
                let full_prompt = format!("{system_prompt}\n\n{user_prompt}");
                let response = agent.prompt_multi_turn(&full_prompt, 50).await?;
                Ok(StructuredResponse::PlainText(response))
            }
        }
    }

    async fn verify_response_if_enabled(
        &self,
        capability: &str,
        output_type: &str,
        system_prompt: &str,
        user_prompt: &str,
        response: StructuredResponse,
    ) -> Result<StructuredResponse> {
        if !self.should_run_critic(capability, output_type) {
            return Ok(response);
        }

        let (critic_prompt, critic_output_type) = match self.load_capability_config("verify") {
            Ok(config) => config,
            Err(error) => {
                crate::agents::debug::debug_warning(&format!(
                    "Critic pass skipped: failed to load verify capability: {error}"
                ));
                return Ok(response);
            }
        };
        if critic_output_type != "Critique" {
            crate::agents::debug::debug_warning(&format!(
                "Critic pass skipped: verify capability returned unexpected output_type {critic_output_type}"
            ));
            return Ok(response);
        }

        let critic_task = Self::build_critic_task(capability, user_prompt, &response);
        let critique = match self
            .execute_with_agent::<Critique>(&critic_prompt, &critic_task)
            .await
        {
            Ok(critique) => critique,
            Err(error) => {
                crate::agents::debug::debug_warning(&format!(
                    "Critic pass skipped after generation succeeded: {error}"
                ));
                return Ok(response);
            }
        };

        if !critique.requires_revision {
            return Ok(response);
        }

        if critique.revision_prompt.trim().is_empty() && critique.issues.is_empty() {
            crate::agents::debug::debug_warning(
                "Critic requested a revision without issues or revision_prompt; keeping original artifact",
            );
            return Ok(response);
        }

        let revised_prompt = Self::build_revision_prompt(user_prompt, &critique);
        self.execute_output_type(output_type, system_prompt, &revised_prompt)
            .await
    }

    fn should_run_critic(&self, capability: &str, output_type: &str) -> bool {
        let critic_enabled = self
            .config
            .as_ref()
            .is_none_or(|config| config.critic_enabled);

        critic_enabled
            && matches!(
                (capability, output_type),
                ("commit", "GeneratedMessage")
                    | ("review", "Review")
                    | ("pr", "MarkdownPullRequest")
                    | ("changelog", "MarkdownChangelog")
                    | ("release_notes", "MarkdownReleaseNotes")
            )
    }

    fn build_critic_task(
        capability: &str,
        user_prompt: &str,
        response: &StructuredResponse,
    ) -> String {
        let artifact = Self::serialize_artifact_for_critic(response);
        format!(
            "## Capability\n{capability}\n\n## Original Task\n{user_prompt}\n\n## Generated Artifact\n```json\n{artifact}\n```"
        )
    }

    fn serialize_artifact_for_critic(response: &StructuredResponse) -> String {
        match response {
            StructuredResponse::CommitMessage(message) => serde_json::to_string_pretty(message),
            StructuredResponse::PullRequest(pr) => serde_json::to_string_pretty(pr),
            StructuredResponse::Changelog(changelog) => serde_json::to_string_pretty(changelog),
            StructuredResponse::ReleaseNotes(notes) => serde_json::to_string_pretty(notes),
            StructuredResponse::Review(review) => serde_json::to_string_pretty(review),
            StructuredResponse::SemanticBlame(text) | StructuredResponse::PlainText(text) => {
                serde_json::to_string_pretty(text)
            }
        }
        .unwrap_or_else(|_| response.to_string())
    }

    fn build_revision_prompt(user_prompt: &str, critique: &Critique) -> String {
        let issues = if critique.issues.is_empty() {
            String::new()
        } else {
            format!(
                "\n\nIssues:\n{}",
                critique
                    .issues
                    .iter()
                    .map(|issue| format!("- [{}] {}: {}", issue.severity, issue.title, issue.body))
                    .collect::<Vec<_>>()
                    .join("\n")
            )
        };
        let revision_prompt = if critique.revision_prompt.trim().is_empty() {
            "Address the material issues listed above."
        } else {
            critique.revision_prompt.trim()
        };
        format!(
            "{user_prompt}\n\n## Critic Feedback\nThe first draft contained unsupported or misleading claims. Regenerate the artifact once, preserving the original task and fixing these issues.{issues}\n\nRevision instruction:\n{}",
            revision_prompt
        )
    }

    /// Execute a task with streaming, calling the callback with each text chunk
    ///
    /// This enables real-time display of LLM output in the TUI.
    /// The callback receives `(chunk, aggregated_text)` for each delta.
    ///
    /// Returns the final structured response after streaming completes.
    ///
    /// # Errors
    ///
    /// Returns an error when capability loading, agent construction, or streaming fails.
    pub async fn execute_task_streaming<F>(
        &mut self,
        capability: &str,
        user_prompt: &str,
        mut on_chunk: F,
    ) -> Result<StructuredResponse>
    where
        F: FnMut(&str, &str) + Send,
    {
        use crate::agents::status::IrisPhase;
        use crate::messages::get_capability_message;
        use futures::StreamExt;
        use rig::agent::MultiTurnStreamItem;
        use rig::streaming::{StreamedAssistantContent, StreamingPrompt};

        // Show initializing status
        let waiting_msg = get_capability_message(capability);
        crate::iris_status_dynamic!(IrisPhase::Initializing, waiting_msg.text, 1, 4);

        // Load the capability config
        let (mut system_prompt, output_type) = self.load_capability_config(capability)?;

        // Inject style instructions
        self.inject_style_instructions(&mut system_prompt, capability);

        // Set current capability
        self.current_capability = Some(capability.to_string());

        // Update status
        crate::iris_status_dynamic!(
            IrisPhase::Analysis,
            "🔍 Iris is analyzing your changes...",
            2,
            4
        );

        // Build the full prompt (simplified for streaming - no JSON schema enforcement)
        let full_prompt = format!(
            "{}\n\n{}\n\n{}",
            system_prompt,
            user_prompt,
            streaming_response_instructions(capability)
        );

        // Update status
        let gen_msg = get_capability_message(capability);
        crate::iris_status_dynamic!(IrisPhase::Generation, gen_msg.text, 3, 4);

        // Macro to consume a stream and aggregate text
        macro_rules! consume_stream {
            ($stream:expr) => {{
                let mut aggregated_text = String::new();
                let mut stream = $stream;
                while let Some(item) = stream.next().await {
                    match item {
                        Ok(MultiTurnStreamItem::StreamAssistantItem(
                            StreamedAssistantContent::Text(text),
                        )) => {
                            aggregated_text.push_str(&text.text);
                            on_chunk(&text.text, &aggregated_text);
                        }
                        Ok(MultiTurnStreamItem::StreamAssistantItem(
                            StreamedAssistantContent::ToolCall { tool_call, .. },
                        )) => {
                            let tool_name = &tool_call.function.name;
                            let reason = format!("Calling {}", tool_name);
                            crate::iris_status_dynamic!(
                                IrisPhase::ToolExecution {
                                    tool_name: tool_name.clone(),
                                    reason: reason.clone()
                                },
                                format!("🔧 {}", reason),
                                3,
                                4
                            );
                        }
                        Ok(MultiTurnStreamItem::FinalResponse(_)) => break,
                        Err(e) => return Err(anyhow::anyhow!("Streaming error: {}", e)),
                        _ => {}
                    }
                }
                aggregated_text
            }};
        }

        // Build and stream per-provider (streaming types are model-specific)
        let aggregated_text = match self.provider.as_str() {
            "openai" => {
                let agent = self.build_openai_agent_for_streaming(&full_prompt)?;
                let stream = agent.stream_prompt(&full_prompt).multi_turn(50).await;
                consume_stream!(stream)
            }
            "anthropic" => {
                let agent = self.build_anthropic_agent_for_streaming(&full_prompt)?;
                let stream = agent.stream_prompt(&full_prompt).multi_turn(50).await;
                consume_stream!(stream)
            }
            "google" | "gemini" => {
                let agent = self.build_gemini_agent_for_streaming(&full_prompt)?;
                let stream = agent.stream_prompt(&full_prompt).multi_turn(50).await;
                consume_stream!(stream)
            }
            _ => return Err(anyhow::anyhow!("Unsupported provider: {}", self.provider)),
        };

        // Update status
        crate::iris_status_dynamic!(
            IrisPhase::Synthesis,
            "✨ Iris is synthesizing results...",
            4,
            4
        );

        let response = Self::text_to_structured_response(&output_type, aggregated_text);
        crate::iris_status_completed!();
        Ok(response)
    }

    /// Convert raw text to the appropriate structured response type
    fn text_to_structured_response(output_type: &str, text: String) -> StructuredResponse {
        match output_type {
            "GeneratedMessage" => Self::parse_text_as_json::<crate::types::GeneratedMessage>(&text)
                .map_or_else(
                    || StructuredResponse::PlainText(text),
                    StructuredResponse::CommitMessage,
                ),
            "Review" => StructuredResponse::Review(crate::types::Review::from_unstructured(&text)),
            "MarkdownPullRequest" => {
                StructuredResponse::PullRequest(crate::types::MarkdownPullRequest { content: text })
            }
            "MarkdownChangelog" => {
                StructuredResponse::Changelog(crate::types::MarkdownChangelog { content: text })
            }
            "MarkdownReleaseNotes" => {
                StructuredResponse::ReleaseNotes(crate::types::MarkdownReleaseNotes {
                    content: text,
                })
            }
            "SemanticBlame" => StructuredResponse::SemanticBlame(text),
            _ => StructuredResponse::PlainText(text),
        }
    }

    fn parse_text_as_json<T>(text: &str) -> Option<T>
    where
        T: JsonSchema + DeserializeOwned,
    {
        let json = extract_json_from_response(text).ok()?;
        let sanitized_json = sanitize_json_response(&json);
        parse_with_recovery(sanitized_json.as_ref()).ok()
    }

    /// Shared streaming agent configuration
    fn streaming_agent_config(&self) -> (&str, Option<&str>, u64, usize) {
        let fast_model = self.effective_fast_model();
        let api_key = self.get_api_key();
        let subagent_timeout = self
            .config
            .as_ref()
            .map_or(120, |c| c.subagent_timeout_secs);
        let subagent_max_turns = self.config.as_ref().map_or(20, |c| c.subagent_max_turns);
        (fast_model, api_key, subagent_timeout, subagent_max_turns)
    }

    /// Build `OpenAI` agent for streaming (with tools attached)
    fn build_openai_agent_for_streaming(
        &self,
        _prompt: &str,
    ) -> Result<rig::agent::Agent<provider::OpenAIModel>> {
        let (fast_model, api_key, subagent_timeout, subagent_max_turns) =
            self.streaming_agent_config();
        build_streaming_agent!(
            self,
            provider::openai_builder,
            fast_model,
            api_key,
            subagent_timeout,
            subagent_max_turns
        )
    }

    /// Build Anthropic agent for streaming (with tools attached)
    fn build_anthropic_agent_for_streaming(
        &self,
        _prompt: &str,
    ) -> Result<rig::agent::Agent<provider::AnthropicModel>> {
        let (fast_model, api_key, subagent_timeout, subagent_max_turns) =
            self.streaming_agent_config();
        build_streaming_agent!(
            self,
            provider::anthropic_builder,
            fast_model,
            api_key,
            subagent_timeout,
            subagent_max_turns
        )
    }

    /// Build Gemini agent for streaming (with tools attached)
    fn build_gemini_agent_for_streaming(
        &self,
        _prompt: &str,
    ) -> Result<rig::agent::Agent<provider::GeminiModel>> {
        let (fast_model, api_key, subagent_timeout, subagent_max_turns) =
            self.streaming_agent_config();
        build_streaming_agent!(
            self,
            provider::gemini_builder,
            fast_model,
            api_key,
            subagent_timeout,
            subagent_max_turns
        )
    }

    /// Load capability configuration from embedded TOML, returning both prompt and output type
    fn load_capability_config(&self, capability: &str) -> Result<(String, String)> {
        let _ = self; // Keep &self for method syntax consistency
        if capability == "verify" {
            return Self::load_verify_capability_config();
        }

        // Use embedded capability strings - always available regardless of working directory
        let content = match capability {
            "commit" => CAPABILITY_COMMIT,
            "pr" => CAPABILITY_PR,
            "review" => CAPABILITY_REVIEW,
            "changelog" => CAPABILITY_CHANGELOG,
            "release_notes" => CAPABILITY_RELEASE_NOTES,
            "chat" => CAPABILITY_CHAT,
            "semantic_blame" => CAPABILITY_SEMANTIC_BLAME,
            _ => {
                // Return generic prompt for unknown capabilities
                return Ok((
                    format!(
                        "You are helping with a {capability} task. Use the available Git tools to assist the user."
                    ),
                    "PlainText".to_string(),
                ));
            }
        };

        Self::parse_capability_config(content)
    }

    fn load_verify_capability_config() -> Result<(String, String)> {
        if let Some(config) = VERIFY_CAPABILITY_CONFIG.get() {
            return Ok(config.clone());
        }

        let config = Self::parse_capability_config(CAPABILITY_VERIFY)?;
        let _ = VERIFY_CAPABILITY_CONFIG.set(config.clone());
        Ok(config)
    }

    fn parse_capability_config(content: &str) -> Result<(String, String)> {
        let parsed: toml::Value = toml::from_str(content)?;

        let task_prompt = parsed
            .get("task_prompt")
            .and_then(|v| v.as_str())
            .ok_or_else(|| anyhow::anyhow!("No task_prompt found in capability file"))?;

        let output_type = parsed
            .get("output_type")
            .and_then(|v| v.as_str())
            .unwrap_or("PlainText")
            .to_string();

        Ok((task_prompt.to_string(), output_type))
    }

    /// Get the current capability being executed
    #[must_use]
    pub fn current_capability(&self) -> Option<&str> {
        self.current_capability.as_deref()
    }

    /// Simple single-turn execution for basic queries
    ///
    /// # Errors
    ///
    /// Returns an error when the provider request fails.
    pub async fn chat(&self, message: &str) -> Result<String> {
        let agent = self.build_agent()?;
        let response = agent.prompt(message).await?;
        Ok(response)
    }

    /// Set the current capability
    pub fn set_capability(&mut self, capability: &str) {
        self.current_capability = Some(capability.to_string());
    }

    /// Get provider configuration
    #[must_use]
    pub fn provider_config(&self) -> &HashMap<String, String> {
        &self.provider_config
    }

    /// Set provider configuration
    pub fn set_provider_config(&mut self, config: HashMap<String, String>) {
        self.provider_config = config;
    }

    /// Set custom preamble
    pub fn set_preamble(&mut self, preamble: String) {
        self.preamble = Some(preamble);
    }

    /// Set configuration
    pub fn set_config(&mut self, config: crate::config::Config) {
        self.config = Some(config);
    }

    /// Set fast model for subagents
    pub fn set_fast_model(&mut self, fast_model: String) {
        self.fast_model = Some(fast_model);
    }
}

/// Builder for creating `IrisAgent` instances with different configurations
pub struct IrisAgentBuilder {
    provider: String,
    model: String,
    preamble: Option<String>,
}

impl IrisAgentBuilder {
    /// Create a new builder
    #[must_use]
    pub fn new() -> Self {
        Self {
            provider: "openai".to_string(),
            model: "gpt-5.4".to_string(),
            preamble: None,
        }
    }

    /// Set the provider to use
    pub fn with_provider(mut self, provider: impl Into<String>) -> Self {
        self.provider = provider.into();
        self
    }

    /// Set the model to use
    pub fn with_model(mut self, model: impl Into<String>) -> Self {
        self.model = model.into();
        self
    }

    /// Set a custom preamble
    pub fn with_preamble(mut self, preamble: impl Into<String>) -> Self {
        self.preamble = Some(preamble.into());
        self
    }

    /// Build the `IrisAgent`
    ///
    /// # Errors
    ///
    /// Returns an error when the configured provider or model cannot build an agent.
    pub fn build(self) -> Result<IrisAgent> {
        let mut agent = IrisAgent::new(&self.provider, &self.model)?;

        // Apply custom preamble if provided
        if let Some(preamble) = self.preamble {
            agent.set_preamble(preamble);
        }

        Ok(agent)
    }
}

impl Default for IrisAgentBuilder {
    fn default() -> Self {
        Self::new()
    }
}

#[cfg(test)]
mod tests {
    use super::{
        Critique, CritiqueIssue, CritiqueSeverity, IrisAgent, extract_json_from_response,
        find_balanced_braces, sanitize_json_response, streaming_response_instructions,
    };
    use serde_json::Value;
    use std::borrow::Cow;

    #[test]
    fn sanitize_json_response_is_noop_for_valid_payloads() {
        let raw = r#"{"title":"Test","description":"All good"}"#;
        let sanitized = sanitize_json_response(raw);
        assert!(matches!(sanitized, Cow::Borrowed(_)));
        serde_json::from_str::<Value>(sanitized.as_ref()).expect("valid JSON");
    }

    #[test]
    fn sanitize_json_response_escapes_literal_newlines() {
        let raw = "{\"description\": \"Line1
Line2\"}";
        let sanitized = sanitize_json_response(raw);
        assert_eq!(sanitized.as_ref(), "{\"description\": \"Line1\\nLine2\"}");
        serde_json::from_str::<Value>(sanitized.as_ref()).expect("json sanitized");
    }

    #[test]
    fn chat_streaming_instructions_avoid_markdown_suffix() {
        let instructions = streaming_response_instructions("chat");
        assert!(instructions.contains("plain text"));
        assert!(instructions.contains("do not repeat full content"));
        assert!(!instructions.contains("markdown format"));
    }

    #[test]
    fn structured_streaming_instructions_still_use_markdown_suffix() {
        let instructions = streaming_response_instructions("review");
        assert!(instructions.contains("markdown format"));
        assert!(instructions.contains("well-structured"));
    }

    #[test]
    fn find_balanced_braces_returns_first_balanced_pair() {
        let (start, end) = find_balanced_braces("prefix {\"a\":1} suffix").expect("balanced pair");
        assert_eq!(&"prefix {\"a\":1} suffix"[start..end], "{\"a\":1}");
    }

    #[test]
    fn find_balanced_braces_returns_none_for_unbalanced() {
        assert_eq!(find_balanced_braces("no braces here"), None);
        assert_eq!(find_balanced_braces("{ unclosed"), None);
    }

    #[test]
    fn extract_json_skips_github_actions_expression_false_positive() {
        // Regression for a real failure: a diff hunk that adds
        // `commit_message: "Update to ${{ github.ref_name }}"` to a workflow
        // lands in the model's response. The old scanner grabbed `{{ github.ref_name }}`
        // as its first balanced pair and errored out before seeing the real JSON.
        let response = r#"Looking at the diff, I see the new value `${{ github.ref_name }}` replacing the old bash expansion. Here's the commit:

{"emoji": "🔧", "title": "Upgrade AUR deploy action", "message": "Bump to v4.1.2 to fix bash --command error."}
"#;
        let extracted = extract_json_from_response(response).expect("should recover real JSON");
        let parsed: Value = serde_json::from_str(&extracted).expect("extracted value is JSON");
        assert_eq!(parsed["emoji"], "🔧");
        assert_eq!(parsed["title"], "Upgrade AUR deploy action");
    }

    #[test]
    fn extract_json_from_pure_json_response() {
        let response = r##"{"content": "# Heading\n\nBody text."}"##;
        let extracted = extract_json_from_response(response).expect("pure JSON passes through");
        assert_eq!(extracted, response);
    }

    #[test]
    fn streamed_generated_message_text_becomes_commit_response() {
        let response = r#"```json
{"emoji":"🔧","title":"Wire streaming commit output","message":"Parse streamed JSON into the commit response type."}
```"#;

        let structured =
            IrisAgent::text_to_structured_response("GeneratedMessage", response.to_string());

        let super::StructuredResponse::CommitMessage(message) = structured else {
            panic!("expected commit message response");
        };
        assert_eq!(message.emoji.as_deref(), Some("🔧"));
        assert_eq!(message.title, "Wire streaming commit output");
        assert_eq!(
            message.message,
            "Parse streamed JSON into the commit response type."
        );
    }

    #[test]
    fn invalid_streamed_generated_message_stays_plain_text() {
        let structured =
            IrisAgent::text_to_structured_response("GeneratedMessage", "not json".to_string());

        let super::StructuredResponse::PlainText(text) = structured else {
            panic!("expected plain text fallback");
        };
        assert_eq!(text, "not json");
    }

    #[test]
    fn critic_runs_for_configured_structured_artifacts() {
        let mut agent = IrisAgent::new("openai", "gpt-5.4").expect("agent should build");
        agent.set_config(crate::config::Config::default());

        assert!(agent.should_run_critic("review", "Review"));
        assert!(agent.should_run_critic("commit", "GeneratedMessage"));
        assert!(!agent.should_run_critic("chat", "PlainText"));
        assert!(!agent.should_run_critic("semantic_blame", "SemanticBlame"));
    }

    #[test]
    fn critic_can_be_disabled_by_config() {
        let config = crate::config::Config {
            critic_enabled: false,
            ..crate::config::Config::default()
        };
        let mut agent = IrisAgent::new("openai", "gpt-5.4").expect("agent should build");
        agent.set_config(config);

        assert!(!agent.should_run_critic("review", "Review"));
    }

    #[test]
    fn critic_revision_prompt_includes_material_issues() {
        let critique = Critique {
            requires_revision: true,
            issues: vec![CritiqueIssue {
                title: "Unsupported auth claim".to_string(),
                body: "The diff only updates docs.".to_string(),
                severity: CritiqueSeverity::High,
            }],
            revision_prompt: "Remove the auth-hardening claim.".to_string(),
            confidence: 91,
        };

        let prompt = IrisAgent::build_revision_prompt("Original task", &critique);

        assert!(prompt.contains("Original task"));
        assert!(prompt.contains("[high] Unsupported auth claim"));
        assert!(prompt.contains("Remove the auth-hardening claim."));
    }

    #[test]
    fn critic_revision_prompt_falls_back_to_issues() {
        let critique = Critique {
            requires_revision: true,
            issues: vec![CritiqueIssue {
                title: "Unsupported auth claim".to_string(),
                body: "The diff only updates docs.".to_string(),
                severity: CritiqueSeverity::High,
            }],
            revision_prompt: String::new(),
            confidence: 91,
        };

        let prompt = IrisAgent::build_revision_prompt("Original task", &critique);

        assert!(prompt.contains("Address the material issues listed above."));
    }

    #[test]
    fn critic_revision_prompt_omits_empty_issues_section() {
        let critique = Critique {
            requires_revision: true,
            issues: Vec::new(),
            revision_prompt: "Remove the unsupported claim.".to_string(),
            confidence: 91,
        };

        let prompt = IrisAgent::build_revision_prompt("Original task", &critique);

        assert!(!prompt.contains("Issues:"));
        assert!(prompt.contains("Remove the unsupported claim."));
    }

    #[test]
    fn critic_artifact_serialization_strips_response_variant_wrapper() {
        let response = super::StructuredResponse::CommitMessage(crate::types::GeneratedMessage {
            emoji: None,
            title: "Add critic pass".to_string(),
            message: "Check generated artifacts before returning them.".to_string(),
            completion_message: None,
        });

        let artifact = IrisAgent::serialize_artifact_for_critic(&response);

        assert!(artifact.contains("\"title\": \"Add critic pass\""));
        assert!(!artifact.contains("CommitMessage"));
    }

    #[test]
    fn critic_severity_normalizes_unknown_values_to_medium() {
        let severity: CritiqueSeverity =
            serde_json::from_str("\"totally-fine\"").expect("severity should deserialize");

        assert_eq!(severity, CritiqueSeverity::Medium);
    }

    #[test]
    fn extract_json_errors_when_no_candidate_parses() {
        // A single malformed candidate and no other braces: we surface the
        // parse error with a preview so the user sees what went wrong.
        let response = "prose ${{ template }} more prose";
        let err = extract_json_from_response(response).expect_err("should fail");
        let msg = err.to_string();
        assert!(
            msg.contains("Preview:"),
            "error should include a preview: {msg}"
        );
    }

    #[test]
    fn pr_review_emoji_styling_uses_a_compact_gitmoji_guide() {
        let mut prompt = String::new();
        IrisAgent::inject_pr_review_emoji_styling(&mut prompt);

        assert!(prompt.contains("Common gitmoji choices:"));
        assert!(prompt.contains("`:feat:`"));
        assert!(prompt.contains("`:fix:`"));
        assert!(!prompt.contains("`:accessibility:`"));
        assert!(!prompt.contains("`:analytics:`"));
    }
}