async def execute(
    self, input_data: Any, deps: AgentDependencies | None = None
) -> AgentResult:
    """
    Execute the agent with input data.

    This is the main entry point for executing an agent. It handles
    initialization, execution, and result processing while tracking
    execution metrics and errors.

    Args:
        input_data: The input data to process. Can be a string, dict,
                   or any structured data appropriate for the agent type.
        deps: Optional agent dependencies. If not provided, uses
             the agent's default dependencies.

    Returns:
        AgentResult: The execution result containing success status,
                   processed data, execution metrics, and any errors.

    Raises:
        RuntimeError: If the agent is not properly initialized.

    Examples:
        Basic execution:

        ```python
        agent = SearchAgent()
        deps = AgentDependencies.from_config(config)
        result = await agent.execute("machine learning", deps)

        if result.success:
            print(f"Results: {result.data}")
        else:
            print(f"Error: {result.error}")
        ```

        With custom dependencies:

        ```python
        custom_deps = AgentDependencies(
            model_name="openai:gpt-4",
            api_keys={"openai": "your-key"},
            config={"temperature": 0.8}
        )
        result = await agent.execute("research query", custom_deps)
        ```
    """
    start_time = time.time()
    self.status = AgentStatus.RUNNING

    try:
        if not self._agent:
            return AgentResult(
                success=False,
                error="Agent not properly initialized",
                agent_type=self.agent_type,
            )

        # Use provided deps or default
        execution_deps = deps or self.dependencies

        # Execute with Pydantic AI
        result = await self._agent.run(input_data, deps=execution_deps)

        execution_time = time.time() - start_time

        agent_result = AgentResult(
            success=True,
            data=self._process_result(result),
            execution_time=execution_time,
            agent_type=self.agent_type,
        )

    except Exception as e:
        execution_time = time.time() - start_time
        agent_result = AgentResult(
            success=False,
            error=str(e),
            execution_time=execution_time,
            agent_type=self.agent_type,
        )

        self.status = AgentStatus.FAILED
        self.history.record(self.agent_type, agent_result)
        return agent_result
    else:
        self.status = AgentStatus.COMPLETED
        self.history.record(self.agent_type, agent_result)
        return agent_result

def execute_sync(
    self, input_data: Any, deps: AgentDependencies | None = None
) -> AgentResult:
    """Synchronous execution wrapper."""
    return asyncio.run(self.execute(input_data, deps))

async def execute(
    self, input_data: Any, deps: AgentDependencies | None = None
) -> AgentResult:
    """
    Execute the agent with input data.

    This is the main entry point for executing an agent. It handles
    initialization, execution, and result processing while tracking
    execution metrics and errors.

    Args:
        input_data: The input data to process. Can be a string, dict,
                   or any structured data appropriate for the agent type.
        deps: Optional agent dependencies. If not provided, uses
             the agent's default dependencies.

    Returns:
        AgentResult: The execution result containing success status,
                   processed data, execution metrics, and any errors.

    Raises:
        RuntimeError: If the agent is not properly initialized.

    Examples:
        Basic execution:

        ```python
        agent = SearchAgent()
        deps = AgentDependencies.from_config(config)
        result = await agent.execute("machine learning", deps)

        if result.success:
            print(f"Results: {result.data}")
        else:
            print(f"Error: {result.error}")
        ```

        With custom dependencies:

        ```python
        custom_deps = AgentDependencies(
            model_name="openai:gpt-4",
            api_keys={"openai": "your-key"},
            config={"temperature": 0.8}
        )
        result = await agent.execute("research query", custom_deps)
        ```
    """
    start_time = time.time()
    self.status = AgentStatus.RUNNING

    try:
        if not self._agent:
            return AgentResult(
                success=False,
                error="Agent not properly initialized",
                agent_type=self.agent_type,
            )

        # Use provided deps or default
        execution_deps = deps or self.dependencies

        # Execute with Pydantic AI
        result = await self._agent.run(input_data, deps=execution_deps)

        execution_time = time.time() - start_time

        agent_result = AgentResult(
            success=True,
            data=self._process_result(result),
            execution_time=execution_time,
            agent_type=self.agent_type,
        )

    except Exception as e:
        execution_time = time.time() - start_time
        agent_result = AgentResult(
            success=False,
            error=str(e),
            execution_time=execution_time,
            agent_type=self.agent_type,
        )

        self.status = AgentStatus.FAILED
        self.history.record(self.agent_type, agent_result)
        return agent_result
    else:
        self.status = AgentStatus.COMPLETED
        self.history.record(self.agent_type, agent_result)
        return agent_result

def execute_sync(
    self, input_data: Any, deps: AgentDependencies | None = None
) -> AgentResult:
    """Synchronous execution wrapper."""
    return asyncio.run(self.execute(input_data, deps))

async def fuse_data(self, fusion_request: DataFusionRequest) -> FusedDataset:
    """Fuse bioinformatics data from multiple sources."""
    result = await self.execute(fusion_request.model_dump())

    if result.success and "fused_dataset" in result.data:
        return FusedDataset(**result.data["fused_dataset"])
    return FusedDataset(
        dataset_id="error",
        name="Error Dataset",
        description="Failed to fuse data",
        source_databases=[],
    )

async def perform_reasoning(
    self, task: ReasoningTask, dataset: FusedDataset
) -> dict[str, Any]:
    """Perform reasoning on fused bioinformatics data."""
    reasoning_params = {"task": task.model_dump(), "dataset": dataset.model_dump()}

    result = await self.execute(reasoning_params)
    return result.data if result.success else {"error": result.error}

async def execute(
    self, input_data: Any, deps: AgentDependencies | None = None
) -> AgentResult:
    """
    Execute the agent with input data.

    This is the main entry point for executing an agent. It handles
    initialization, execution, and result processing while tracking
    execution metrics and errors.

    Args:
        input_data: The input data to process. Can be a string, dict,
                   or any structured data appropriate for the agent type.
        deps: Optional agent dependencies. If not provided, uses
             the agent's default dependencies.

    Returns:
        AgentResult: The execution result containing success status,
                   processed data, execution metrics, and any errors.

    Raises:
        RuntimeError: If the agent is not properly initialized.

    Examples:
        Basic execution:

        ```python
        agent = SearchAgent()
        deps = AgentDependencies.from_config(config)
        result = await agent.execute("machine learning", deps)

        if result.success:
            print(f"Results: {result.data}")
        else:
            print(f"Error: {result.error}")
        ```

        With custom dependencies:

        ```python
        custom_deps = AgentDependencies(
            model_name="openai:gpt-4",
            api_keys={"openai": "your-key"},
            config={"temperature": 0.8}
        )
        result = await agent.execute("research query", custom_deps)
        ```
    """
    start_time = time.time()
    self.status = AgentStatus.RUNNING

    try:
        if not self._agent:
            return AgentResult(
                success=False,
                error="Agent not properly initialized",
                agent_type=self.agent_type,
            )

        # Use provided deps or default
        execution_deps = deps or self.dependencies

        # Execute with Pydantic AI
        result = await self._agent.run(input_data, deps=execution_deps)

        execution_time = time.time() - start_time

        agent_result = AgentResult(
            success=True,
            data=self._process_result(result),
            execution_time=execution_time,
            agent_type=self.agent_type,
        )

    except Exception as e:
        execution_time = time.time() - start_time
        agent_result = AgentResult(
            success=False,
            error=str(e),
            execution_time=execution_time,
            agent_type=self.agent_type,
        )

        self.status = AgentStatus.FAILED
        self.history.record(self.agent_type, agent_result)
        return agent_result
    else:
        self.status = AgentStatus.COMPLETED
        self.history.record(self.agent_type, agent_result)
        return agent_result

def execute_sync(
    self, input_data: Any, deps: AgentDependencies | None = None
) -> AgentResult:
    """Synchronous execution wrapper."""
    return asyncio.run(self.execute(input_data, deps))

async def manage_files(
    self, operation: str, context: DeepAgentState | None = None
) -> AgentExecutionResult:
    """Manage filesystem operations."""
    if self._deep_agent:
        return await self._deep_agent.manage_files(operation, context)
    # Fallback to standard agent execution
    result = await self.execute({"operation": operation, "context": context})
    return AgentExecutionResult(
        success=result.success,
        result=result.data,
        error=result.error,
        execution_time=result.execution_time,
        tools_used=["standard_filesystem"],
    )

async def execute(
    self, input_data: Any, deps: AgentDependencies | None = None
) -> AgentResult:
    """
    Execute the agent with input data.

    This is the main entry point for executing an agent. It handles
    initialization, execution, and result processing while tracking
    execution metrics and errors.

    Args:
        input_data: The input data to process. Can be a string, dict,
                   or any structured data appropriate for the agent type.
        deps: Optional agent dependencies. If not provided, uses
             the agent's default dependencies.

    Returns:
        AgentResult: The execution result containing success status,
                   processed data, execution metrics, and any errors.

    Raises:
        RuntimeError: If the agent is not properly initialized.

    Examples:
        Basic execution:

        ```python
        agent = SearchAgent()
        deps = AgentDependencies.from_config(config)
        result = await agent.execute("machine learning", deps)

        if result.success:
            print(f"Results: {result.data}")
        else:
            print(f"Error: {result.error}")
        ```

        With custom dependencies:

        ```python
        custom_deps = AgentDependencies(
            model_name="openai:gpt-4",
            api_keys={"openai": "your-key"},
            config={"temperature": 0.8}
        )
        result = await agent.execute("research query", custom_deps)
        ```
    """
    start_time = time.time()
    self.status = AgentStatus.RUNNING

    try:
        if not self._agent:
            return AgentResult(
                success=False,
                error="Agent not properly initialized",
                agent_type=self.agent_type,
            )

        # Use provided deps or default
        execution_deps = deps or self.dependencies

        # Execute with Pydantic AI
        result = await self._agent.run(input_data, deps=execution_deps)

        execution_time = time.time() - start_time

        agent_result = AgentResult(
            success=True,
            data=self._process_result(result),
            execution_time=execution_time,
            agent_type=self.agent_type,
        )

    except Exception as e:
        execution_time = time.time() - start_time
        agent_result = AgentResult(
            success=False,
            error=str(e),
            execution_time=execution_time,
            agent_type=self.agent_type,
        )

        self.status = AgentStatus.FAILED
        self.history.record(self.agent_type, agent_result)
        return agent_result
    else:
        self.status = AgentStatus.COMPLETED
        self.history.record(self.agent_type, agent_result)
        return agent_result

def execute_sync(
    self, input_data: Any, deps: AgentDependencies | None = None
) -> AgentResult:
    """Synchronous execution wrapper."""
    return asyncio.run(self.execute(input_data, deps))

async def handle_general_task(
    self, task_description: str, context: DeepAgentState | None = None
) -> AgentExecutionResult:
    """Handle general-purpose tasks."""
    if self._deep_agent:
        return await self._deep_agent.execute(task_description, context)
    # Fallback to standard agent execution
    result = await self.execute({"task": task_description, "context": context})
    return AgentExecutionResult(
        success=result.success,
        result=result.data,
        error=result.error,
        execution_time=result.execution_time,
        tools_used=["standard_general"],
    )