async def analyze_error(
        self,
        code: str,
        error_message: str,
        language: str,
        context: dict[str, Any] | None = None,
    ) -> dict[str, Any]:
        """Analyze an execution error and provide insights.

        Args:
            code: The code that failed
            error_message: The error message from execution
            language: The language of the code
            context: Additional context about the execution

        Returns:
            Dictionary with error analysis
        """
        context_info = context or {}
        execution_context = f"""
Execution Context:
- Language: {language}
- Working Directory: {context_info.get("working_directory", "unknown")}
- Environment: {context_info.get("environment", "unknown")}
- Timeout: {context_info.get("timeout", "unknown")}
"""

        analysis_prompt = f"""
Please analyze this code execution error:

ORIGINAL CODE:
```python
{code}
```

ERROR MESSAGE:
```
{error_message}
```

{execution_context}

Provide a detailed analysis of what went wrong and how to fix it.
"""

        result = await self.analysis_agent.run(analysis_prompt)
        analysis_response = str(result.data).strip()

        # Parse the structured response
        analysis = self._parse_analysis_response(analysis_response)

        return {
            "error_type": analysis.get("error_type", "unknown"),
            "root_cause": analysis.get("root_cause", "Unable to determine"),
            "impact": analysis.get("impact", "Prevents code execution"),
            "recommendations": analysis.get("recommendations", []),
            "prevention": analysis.get("prevention", "Add proper error handling"),
            "raw_analysis": analysis_response,
        }

def create_improved_code_block(
    self, improvement_result: dict[str, Any]
) -> CodeBlock:
    """Create a CodeBlock from improvement results.

    Args:
        improvement_result: Result from improve_code method

    Returns:
        CodeBlock instance
    """
    return CodeBlock(
        code=improvement_result["improved_code"],
        language=improvement_result["language"],
    )

async def improve_code(
    self,
    original_code: str,
    error_message: str,
    language: str,
    context: dict[str, Any] | None = None,
    improvement_focus: str = "fix_errors",
) -> dict[str, Any]:
    """Improve code based on error analysis.

    Args:
        original_code: The original code that failed
        error_message: The error message from execution
        language: The language of the code
        context: Additional execution context
        improvement_focus: Focus of improvement ("fix_errors", "optimize", "robustness")

    Returns:
        Dictionary with improved code and analysis
    """
    context_info = context or {}

    if improvement_focus == "fix_errors":
        improvement_prompt = self._create_error_fix_prompt(
            original_code, error_message, language, context_info
        )
        agent = self.improvement_agent
    elif improvement_focus == "optimize":
        improvement_prompt = self._create_optimization_prompt(
            original_code, language, context_info
        )
        agent = self.optimization_agent
    else:  # robustness
        improvement_prompt = self._create_robustness_prompt(
            original_code, language, context_info
        )
        agent = self.improvement_agent

    result = await agent.run(improvement_prompt)
    improvement_response = str(result.data).strip()

    # Parse the improvement response
    improved_code = self._extract_improved_code(improvement_response)
    explanation = self._extract_explanation(improvement_response)

    return {
        "original_code": original_code,
        "improved_code": improved_code,
        "language": language,
        "improvement_focus": improvement_focus,
        "explanation": explanation,
        "raw_response": improvement_response,
    }

async def iterative_improve(
    self,
    code: str,
    language: str,
    test_function: Any,
    max_iterations: int = 3,
    context: dict[str, Any] | None = None,
) -> dict[str, Any]:
    """Iteratively improve code until it works or max iterations reached.

    Args:
        code: Initial code to improve
        language: Language of the code
        test_function: Function to test code execution (should return error message or None)
        max_iterations: Maximum improvement iterations
        context: Additional context

    Returns:
        Dictionary with final result and improvement history
    """
    improvement_history = []
    current_code = code

    for iteration in range(max_iterations):
        # Test current code
        error_message = await test_function(current_code, language)

        if error_message is None:
            # Code works successfully
            return {
                "success": True,
                "final_code": current_code,
                "iterations_used": iteration,
                "improvement_history": improvement_history,
                "error_message": None,
            }

        # Analyze the error
        analysis = await self.analyze_error(
            current_code, error_message, language, context
        )

        # Improve the code
        improvement = await self.improve_code(
            current_code, error_message, language, context, "fix_errors"
        )

        # Update for next iteration
        current_code = improvement["improved_code"]

        improvement_history.append(
            {
                "iteration": iteration + 1,
                "original_code": improvement["original_code"],
                "error_message": error_message,
                "analysis": analysis,
                "improvement": improvement,
            }
        )

    # Max iterations reached, return best attempt
    final_error = await test_function(current_code, language)

    return {
        "success": final_error is None,
        "final_code": current_code,
        "iterations_used": max_iterations,
        "improvement_history": improvement_history,
        "error_message": final_error,
    }

async def analyze_and_improve_code(
    self,
    code: str,
    error_message: str,
    language: str,
    context: dict[str, Any] | None = None,
) -> dict[str, Any]:
    """Analyze an error and improve the code.

    Args:
        code: The code that failed
        error_message: The error message from execution
        language: Language of the code
        context: Additional context

    Returns:
        Improvement results with analysis and improved code
    """
    # Analyze the error
    analysis = await self.improvement_agent.analyze_error(
        code=code, error_message=error_message, language=language, context=context
    )

    # Improve the code
    improvement = await self.improvement_agent.improve_code(
        original_code=code,
        error_message=error_message,
        language=language,
        context=context,
        improvement_focus="fix_errors",
    )

    return {
        "analysis": analysis,
        "improvement": improvement,
        "original_code": code,
        "improved_code": improvement["improved_code"],
        "language": language,
    }

async def execute_code_only(
    self, code: str, language: str, **kwargs
) -> dict[str, Any]:
    """Execute code without generating it.

    Args:
        code: Code to execute
        language: Language of the code
        **kwargs: Execution parameters

    Returns:
        Execution results dictionary
    """
    return await self.execution_agent.execute_code(code, language)

async def generate_code_only(
    self, user_message: str, code_type: str | None = None
) -> tuple[str, str]:
    """Generate code without executing it.

    Args:
        user_message: Natural language description
        code_type: Optional code type specification

    Returns:
        Tuple of (detected_code_type, generated_code)
    """
    return await self.generation_agent.generate_code(user_message, code_type)

def get_config(self) -> dict[str, Any]:
    """Get current configuration."""
    return self.config.dict()

def get_supported_environments(self) -> list[str]:
    """Get list of supported execution environments."""
    return self.config.supported_environments.copy()

async def iterative_improve_and_execute(
    self,
    user_message: str,
    code_type: str | None = None,
    max_iterations: int = 3,
    **kwargs,
) -> AgentResult:
    """Iteratively improve and execute code until it works.

    Args:
        user_message: Natural language description
        code_type: Optional code type specification
        max_iterations: Maximum improvement iterations
        **kwargs: Additional execution parameters

    Returns:
        AgentResult with final successful execution or last attempt
    """
    # Generate initial code
    detected_type, generated_code = await self.generation_agent.generate_code(
        user_message, code_type
    )

    # Create test function that executes code and returns error or None
    async def test_execution(code: str, language: str) -> str | None:
        result = await self.execution_agent.execute_code(code, language)
        return result.get("error") if not result.get("success") else None

    # Iteratively improve the code
    improvement_result = await self.improvement_agent.iterative_improve(
        code=generated_code,
        language=detected_type,
        test_function=test_execution,
        max_iterations=max_iterations,
        context={
            "user_request": user_message,
            "code_type": detected_type,
        },
    )

    # Execute the final code one more time to get the result
    final_result = await test_execution(
        improvement_result["final_code"], detected_type
    )

    # Format the response
    messages = []
    from DeepResearch.src.datatypes.agent_framework_content import TextContent
    from DeepResearch.src.datatypes.agent_framework_types import ChatMessage, Role

    # Code message
    code_content = f"**Final {detected_type.upper()} Code:**\n\n```python\n{improvement_result['final_code']}\n```"
    messages.append(
        ChatMessage(role=Role.ASSISTANT, contents=[TextContent(text=code_content)])
    )

    # Result message
    if improvement_result["success"]:
        result_content = f"**✅ Success after {improvement_result['iterations_used']} iterations!**\n\n"
        result_content += f"**Execution Result:**\n```\n{final_result or 'Code executed successfully'}\n```"
    else:
        result_content = (
            f"**❌ Failed after {max_iterations} improvement attempts**\n\n"
        )
        result_content += (
            f"**Final Error:**\n```\n{final_result or 'Unknown error'}\n```"
        )

    # Add improvement summary
    if improvement_result["improvement_history"]:
        result_content += f"\n\n**Improvement Summary:** {len(improvement_result['improvement_history'])} fixes applied"

    messages.append(
        ChatMessage(
            role=Role.ASSISTANT, contents=[TextContent(text=result_content)]
        )
    )

    # Add detailed improvement history
    if improvement_result["improvement_history"]:
        history_content = "**Improvement History:**\n\n"
        for i, hist in enumerate(improvement_result["improvement_history"], 1):
            history_content += f"**Attempt {i}:**\n"
            history_content += f"- **Error:** {hist['error_message'][:100]}{'...' if len(hist['error_message']) > 100 else ''}\n"
            history_content += f"- **Fix:** {hist['improvement']['explanation'][:150]}{'...' if len(hist['improvement']['explanation']) > 150 else ''}\n\n"

        messages.append(
            ChatMessage(
                role=Role.ASSISTANT, contents=[TextContent(text=history_content)]
            )
        )

    from DeepResearch.src.datatypes.agent_framework_types import AgentRunResponse

    return AgentResult(
        success=improvement_result["success"],
        data={
            "response": AgentRunResponse(messages=messages),
            "improvement_history": improvement_result["improvement_history"],
            "iterations_used": improvement_result["iterations_used"],
            "final_code": improvement_result["final_code"],
            "code_type": detected_type,
        },
        metadata={
            "orchestrator": "code_execution_improvement",
            "improvement_iterations": improvement_result["iterations_used"],
            "success": improvement_result["success"],
        },
        error=None if improvement_result["success"] else final_result,
        execution_time=0.0,  # Would need to track actual timing
        agent_type=AgentType.EXECUTOR,
    )

async def process_request(
    self,
    user_message: str,
    code_type: str | None = None,
    use_workflow: bool | None = None,
    **kwargs,
) -> AgentResult:
    """Process a user request for code generation and execution.

    Args:
        user_message: Natural language description of desired operation
        code_type: Optional code type specification ("bash", "python", or None for auto)
        use_workflow: Whether to use the state machine workflow (overrides config)
        **kwargs: Additional execution parameters

    Returns:
        AgentResult with execution outcome
    """
    start_time = time.time()

    try:
        # Determine whether to use workflow
        use_workflow_mode = (
            use_workflow if use_workflow is not None else self.config.use_workflow
        )

        if use_workflow_mode and self.workflow:
            # Use state machine workflow
            result = await self._execute_workflow(user_message, code_type, **kwargs)
        else:
            # Use direct agent system
            result = await self._execute_direct(user_message, code_type, **kwargs)

        execution_time = time.time() - start_time

        return AgentResult(
            success=result is not None,
            data={
                "response": result,
                "execution_time": execution_time,
                "code_type": code_type,
                "workflow_used": use_workflow_mode,
            }
            if result
            else {},
            metadata={
                "orchestrator": "code_execution",
                "generation_model": self.config.generation_model,
                "execution_config": self.config.dict(),
            },
            error=None,
            execution_time=execution_time,
            agent_type=AgentType.EXECUTOR,
        )

    except Exception as e:
        execution_time = time.time() - start_time
        return AgentResult(
            success=False,
            data={},
            error=f"Orchestration failed: {e!s}",
            execution_time=execution_time,
            agent_type=AgentType.EXECUTOR,
        )

def update_config(self, **kwargs) -> None:
    """Update orchestrator configuration."""
    for key, value in kwargs.items():
        if hasattr(self.config, key):
            setattr(self.config, key, value)

    # Reinitialize agents if necessary
    if any(
        key in kwargs
        for key in ["generation_model", "max_retries", "generation_timeout"]
    ):
        self.generation_agent = CodeGenerationAgent(
            model_name=self.config.generation_model,
            max_retries=self.config.max_retries,
            timeout=self.config.generation_timeout,
        )

    if any(
        key in kwargs
        for key in [
            "use_docker",
            "use_jupyter",
            "jupyter_config",
            "max_retries",
            "execution_timeout",
        ]
    ):
        self.execution_agent = CodeExecutionAgent(
            model_name=self.config.generation_model,
            use_docker=self.config.use_docker,
            use_jupyter=self.config.use_jupyter,
            jupyter_config=self.config.jupyter_config,
            max_retries=self.config.max_retries,
            timeout=self.config.execution_timeout,
        )