# Install copier (recommended via pipx for isolation)
pipx install copier

# Or via pip
pip install copier

# Interactive mode — prompts for all configuration
copier copy gh:omics-os/lobster-agent-template my-agent

# Non-interactive with defaults (good for CI/scripts)
copier copy gh:omics-os/lobster-agent-template my-agent --defaults \
  -d agent_name=my_agent \
  -d display_name="My Agent" \
  -d description="My custom agent for Lobster AI"

my-agent/
├── pyproject.toml              # Package config + entry points (pre-configured)
├── README.md                   # Package documentation
├── LICENSE                     # License file (matches your choice)
├── CHANGELOG.md                # Version history
├── .gitignore                  # Python-specific ignores
├── .github/
│   └── workflows/
│       └── test.yml            # CI: lint, test, contract validation
├── lobster/                    # NO __init__.py (PEP 420 compliant)
│   └── agents/                 # NO __init__.py (PEP 420 compliant)
│       └── {agent_name}/
│           ├── __init__.py     # Exports only (imports from agent file)
│           └── {agent_name}.py # AGENT_CONFIG at top + factory function
└── tests/
    ├── __init__.py
    ├── conftest.py             # MockDataManager + fixtures
    └── test_contract.py        # 18 contract compliance tests

cd my-agent

# Install with dev dependencies
pip install -e ".[dev]"

# Run contract tests (all 18 should pass)
pytest tests/ -v

# Verify agent is discovered by Lobster
lobster agents list | grep {agent_name}

# Get agent info
lobster agents info {agent_name}

# Test in chat
lobster chat
> "Check status using my agent"

cd my-agent
copier update

lobster-{domain}/
├── pyproject.toml              # Package metadata and entry points
├── README.md                   # PyPI description
├── lobster/                    # NO __init__.py here!
│   └── agents/                 # NO __init__.py here!
│       └── {domain}/           # Your domain namespace
│           ├── __init__.py     # Exports only (imports from agent file)
│           ├── {agent}.py      # AGENT_CONFIG at top + factory function
│           ├── config.py       # Domain configuration (optional)
│           ├── prompts.py      # System prompt templates (optional)
│           └── state.py        # State class definitions (optional)
└── tests/
    ├── __init__.py
    ├── conftest.py             # Test fixtures
    └── test_{agent}.py

pip install lobster-ai lobster-transcriptomics lobster-proteomics

# lobster/agents/{domain}/{agent}.py

"""
Your Agent for handling specific bioinformatics workflows.
"""

# =============================================================================
# AGENT_CONFIG FIRST (before heavy imports)
# This is loaded during entry point discovery - keep it fast!
# =============================================================================
from lobster.config.agent_registry import AgentRegistryConfig

AGENT_CONFIG = AgentRegistryConfig(
    # Unique identifier (snake_case) - used in code and CLI
    name="my_agent",

    # Human-readable name shown in UI and logs
    display_name="My Agent",

    # Description used by supervisor for routing decisions
    # Be specific about capabilities so supervisor routes correctly
    description="Specialized agent for domain analysis with feature X and Y",

    # Full module path to factory function
    # Format: "package.module:function_name"
    factory_function="lobster.agents.my_domain.my_agent.my_agent",

    # Tool name supervisor uses to delegate to this agent
    handoff_tool_name="handoff_to_my_agent",

    # When should supervisor hand off to this agent?
    # This directly affects routing accuracy
    handoff_tool_description="Assign domain-specific tasks including X, Y, and Z",

    # Required subscription tier: "free", "premium", or "enterprise"
    # All official Lobster agents are free. Use "premium"/"enterprise" for custom packages.
    tier_requirement="free",

    # PyPI package name (for dependency tracking)
    package_name="lobster-my-domain",

    # Optional: child agents this agent can delegate to
    # child_agents=["sub_agent_a", "sub_agent_b"],

    # Optional: services this agent requires
    # service_dependencies=["my_service"],
)

# =============================================================================
# Heavy imports AFTER (these may take seconds to load)
# =============================================================================
from pathlib import Path
from typing import List, Optional

from langchain_core.tools import tool
from langgraph.prebuilt import create_react_agent

from lobster.config.llm_factory import create_llm
from lobster.config.settings import get_settings
from lobster.core.data_manager_v2 import DataManagerV2
from lobster.utils.logger import get_logger

from pathlib import Path
from typing import List, Optional

from langgraph.graph.state import CompiledGraph

from lobster.core.data_manager_v2 import DataManagerV2


def my_agent(
    data_manager: DataManagerV2,
    callback_handler=None,
    agent_name: str = "my_agent",
    delegation_tools: Optional[List] = None,
    workspace_path: Optional[Path] = None,
    **kwargs,
) -> CompiledGraph:
    """
    Factory function for your specialized agent.

    Args:
        data_manager: DataManagerV2 instance for data operations.
            Use this to access modalities, log tool usage, and track provenance.

        callback_handler: Optional callback for streaming responses.
            Pass to LLM for real-time output in CLI and UI.

        agent_name: Name for this agent instance.
            Used for logging, attribution, and debugging.

        delegation_tools: List of tools for delegating to child agents.
            These are created by graph.py based on child_agents in AGENT_CONFIG.
            Always append these to your tools list!

        workspace_path: Optional workspace path override.
            Falls back to data_manager.workspace_path if not provided.

        **kwargs: Agent-specific parameters (subscription_tier, etc.).
            Allows future extension without breaking existing code.

    Returns:
        CompiledGraph ready for invocation by the LangGraph runtime.
    """
    # Implementation follows...

def my_agent(
    data_manager: DataManagerV2,
    callback_handler=None,
    agent_name: str = "my_agent",
    delegation_tools: Optional[List] = None,
    workspace_path: Optional[Path] = None,
    **kwargs,
) -> CompiledGraph:
    """Create specialized agent for domain analysis."""

    # 1. Get settings and create LLM
    settings = get_settings()
    model_params = settings.get_agent_llm_params(agent_name)
    llm = create_llm(agent_name, model_params, workspace_path=workspace_path)

    # 2. Attach callback handler for streaming
    if callback_handler and hasattr(llm, "with_config"):
        # Normalize to flat list (prevents double-nesting)
        callbacks = callback_handler if isinstance(callback_handler, list) else [callback_handler]
        llm = llm.with_config(callbacks=callbacks)

    # 3. Initialize services (stateless analysis logic)
    my_service = MyService()

    # 4. Define agent tools (see Tool Pattern section)
    @tool
    def analyze_data(modality_name: str, **params) -> str:
        """Analyze the specified data modality."""
        # Tool implementation...

    @tool
    def check_status() -> str:
        """Check available data and analysis status."""
        # Tool implementation...

    # 5. Collect all tools
    tools = [analyze_data, check_status]

    # 6. Add delegation tools if provided (critical for parent agents!)
    if delegation_tools:
        tools = tools + delegation_tools

    # 7. Create system prompt
    system_prompt = create_system_prompt()

    # 8. Return compiled agent
    return create_react_agent(
        model=llm,
        tools=tools,
        prompt=system_prompt,
        name=agent_name,
        state_schema=MyAgentState,  # Optional custom state
    )

[build-system]
requires = ["setuptools>=61.0", "wheel"]
build-backend = "setuptools.build_meta"

[project]
name = "lobster-my-domain"
version = "1.0.0"
description = "My Domain agents for Lobster AI"
readme = "README.md"
license = {text = "MIT"}
authors = [
    {name = "Your Name", email = "you@example.com"}
]
keywords = ["bioinformatics", "my-domain"]
classifiers = [
    "Development Status :: 5 - Production/Stable",
    "Intended Audience :: Science/Research",
    "License :: OSI Approved :: MIT License",
    "Programming Language :: Python :: 3.11",
    "Programming Language :: Python :: 3.12",
    "Programming Language :: Python :: 3.13",
    "Programming Language :: Python :: 3.14",
    "Topic :: Scientific/Engineering :: Bio-Informatics",
]
requires-python = ">=3.11"

# Dependencies - use compatible release constraint
dependencies = [
    "lobster-ai~=1.0.0",  # Allows 1.0.x but not 1.1.0
    # Add domain-specific dependencies
]

[project.urls]
Homepage = "https://your-homepage.com"
Documentation = "https://docs.omics-os.com"
Repository = "https://github.com/your-org/lobster-my-domain"

# =============================================================================
# Entry Points - This is how ComponentRegistry discovers your agents
# =============================================================================
[project.entry-points."lobster.agents"]
my_agent = "lobster.agents.my_domain.my_agent:AGENT_CONFIG"
# Add additional agents from your package:
# sub_agent = "lobster.agents.my_domain.sub_agent:AGENT_CONFIG"

# Optional: State class discovery (if you define custom states)
[project.entry-points."lobster.states"]
MyAgentState = "lobster.agents.my_domain.state:MyAgentState"

# =============================================================================
# Setuptools - Enable namespace package merging
# =============================================================================
[tool.setuptools]
# The `namespaces = true` is critical for PEP 420
packages.find = {where = ["."], include = ["lobster*"], namespaces = true}

[tool.setuptools.package-data]
"*" = ["py.typed"]

# CORRECT - allows patch updates (1.0.1, 1.0.2, etc.)
dependencies = ["lobster-ai~=1.0.0"]

# WRONG - breaks when patches are released
dependencies = ["lobster-ai==1.0.0"]

# tests/test_contract.py
from lobster.testing import AgentContractTestMixin


class TestMyAgent(AgentContractTestMixin):
    """Validate my_agent follows the plugin contract."""

    # Required: module containing AGENT_CONFIG
    agent_module = "lobster.agents.my_domain.my_agent"

    # Required: factory function name
    factory_name = "my_agent"

    # Optional: if factory is in different module than AGENT_CONFIG
    # factory_module = "lobster.agents.my_domain.my_agent_impl"

    # Optional: verify specific tier
    # expected_tier = "free"

pytest tests/test_contract.py -v

# Expected output:
# test_contract.py::TestMyAgent::test_factory_has_standard_params PASSED
# test_contract.py::TestMyAgent::test_no_deprecated_handoff_tools PASSED
# test_contract.py::TestMyAgent::test_agent_config_exists PASSED
# test_contract.py::TestMyAgent::test_agent_config_has_name PASSED
# test_contract.py::TestMyAgent::test_agent_config_has_tier_requirement PASSED

# Install in development mode
cd lobster-my-domain
pip install -e .

# Verify agent is discovered
lobster agents list

# Expected output includes:
# my_agent (lobster-my-domain) - free

lobster agents info my_agent

# Shows:
# Name: my_agent
# Display Name: My Agent
# Package: lobster-my-domain
# Tier: free
# Description: Specialized agent for domain analysis...

lobster chat

# Type a request that should route to your agent
> Analyze my domain data using feature X

# Supervisor should delegate to your agent

lobster-transcriptomics/
├── pyproject.toml
├── README.md
├── lobster/                        # NO __init__.py!
│   └── agents/                     # NO __init__.py!
│       └── transcriptomics/
│           ├── __init__.py         # Public API exports
│           ├── transcriptomics_expert.py  # Parent agent
│           ├── annotation_expert.py       # Sub-agent
│           ├── de_analysis_expert.py      # Sub-agent
│           ├── config.py           # Domain configuration
│           ├── prompts.py          # System prompt templates
│           ├── state.py            # State class definitions
│           └── shared_tools.py     # Tools shared across agents
└── tests/

"""
Transcriptomics Expert Parent Agent for orchestrating single-cell and bulk RNA-seq analysis.

This agent serves as the main orchestrator for transcriptomics analysis, with:
- Shared QC tools (from shared_tools.py) available directly
- Clustering tools (SC-specific) available directly
- Delegation to annotation_expert for cell type annotation
- Delegation to de_analysis_expert for differential expression analysis

The agent auto-detects single-cell vs bulk data and adapts its behavior accordingly.
"""

# =============================================================================
# AGENT_CONFIG FIRST (before heavy imports)
# =============================================================================
# WHY: Entry point discovery imports this module to find AGENT_CONFIG.
# If heavy imports (scanpy, numpy, etc.) come first, discovery takes seconds.
# With AGENT_CONFIG first, discovery completes in <50ms.
from lobster.config.agent_registry import AgentRegistryConfig

AGENT_CONFIG = AgentRegistryConfig(
    # UNIQUE IDENTIFIER
    # - Used in code: ComponentRegistry.get_agent("transcriptomics_expert")
    # - Used in CLI: lobster agents info transcriptomics_expert
    # - Used in config: enabled = ["transcriptomics_expert"]
    name="transcriptomics_expert",

    # DISPLAY NAME
    # - Shown in UI, logs, and error messages
    # - Should be human-readable
    display_name="Transcriptomics Expert",

    # DESCRIPTION (Critical for routing!)
    # - Supervisor uses this to decide which agent handles a request
    # - Be specific: "single-cell AND bulk RNA-seq"
    # - Include key capabilities: "QC, clustering, annotation, DE"
    description="Unified expert for single-cell AND bulk RNA-seq analysis. "
                "Handles QC, clustering, and orchestrates annotation and DE "
                "analysis via specialized sub-agents.",

    # FACTORY FUNCTION PATH
    # - Full module path + function name
    # - ComponentRegistry calls this to create agent instances
    factory_function="lobster.agents.transcriptomics.transcriptomics_expert.transcriptomics_expert",

    # HANDOFF TOOL NAME
    # - Supervisor creates a tool with this name
    # - When supervisor calls this tool, control transfers to this agent
    handoff_tool_name="handoff_to_transcriptomics_expert",

    # HANDOFF TOOL DESCRIPTION
    # - Supervisor's LLM sees this when deciding which tool to use
    # - Include ALL task types this agent handles
    # - Be comprehensive - missed tasks won't route correctly
    handoff_tool_description="Assign ALL transcriptomics analysis tasks "
                            "(single-cell OR bulk RNA-seq): QC, clustering, "
                            "cell type annotation, differential expression, "
                            "pseudobulk, pathway enrichment/functional analysis "
                            "(GO/KEGG/Reactome gene set enrichment)",

    # CHILD AGENTS
    # - Agents this parent can delegate to
    # - Graph builder creates delegation_tools for these
    # - Parent receives tools like: handoff_to_annotation_expert
    child_agents=["annotation_expert", "de_analysis_expert"],

    # TIER REQUIREMENT (optional, defaults to "free")
    # All official Lobster agents are free. The tier system exists for custom packages:
    # - "free": Available to all users (all official agents)
    # - "premium": Custom packages requiring premium subscription
    # - "enterprise": Custom packages requiring enterprise license
    # tier_requirement="free",  # Omitted = defaults to "free"

    # PACKAGE NAME (optional)
    # - PyPI package that provides this agent
    # - Used for dependency tracking and CLI display
    # package_name="lobster-transcriptomics",
)

# =============================================================================
# Heavy imports AFTER
# =============================================================================
# NOW safe to import slow modules - entry point discovery already found AGENT_CONFIG
from datetime import date
from pathlib import Path
from typing import List, Optional

from langchain_core.tools import tool
from langgraph.prebuilt import create_react_agent

from lobster.agents.transcriptomics.prompts import create_transcriptomics_expert_prompt
from lobster.agents.transcriptomics.shared_tools import create_shared_tools
from lobster.agents.transcriptomics.state import TranscriptomicsExpertState
from lobster.config.llm_factory import create_llm
from lobster.config.settings import get_settings
from lobster.core.data_manager_v2 import DataManagerV2
from lobster.services.analysis.clustering_service import ClusteringService
# ... more imports

def transcriptomics_expert(
    data_manager: DataManagerV2,      # REQUIRED: Data operations (modalities, provenance)
    callback_handler=None,             # OPTIONAL: For streaming responses
    agent_name: str = "transcriptomics_expert",  # OPTIONAL: Instance name
    delegation_tools: list = None,     # OPTIONAL: Tools for sub-agent handoffs
    workspace_path: Optional[Path] = None,  # OPTIONAL: Workspace override
):
    """
    Factory function for transcriptomics expert parent agent.

    This agent orchestrates single-cell and bulk RNA-seq analysis.
    It has QC and clustering tools directly, and delegates annotation
    and DE analysis to specialized sub-agents.

    Args:
        data_manager: DataManagerV2 instance for modality management.
            - data_manager.list_modalities() - get available data
            - data_manager.get_modality(name) - retrieve AnnData
            - data_manager.store_modality(name, adata) - save results
            - data_manager.log_tool_usage(..., ir=ir) - track provenance

        callback_handler: Optional callback handler for LLM interactions.
            - Pass to LLM for streaming output
            - Enables real-time responses in CLI and UI

        agent_name: Name identifier for the agent instance.
            - Used in logs for debugging multi-agent flows
            - Appears in provenance tracking

        delegation_tools: List of delegation tools for sub-agents.
            - Created by graph.py from child_agents list
            - Contains: handoff_to_annotation_expert, handoff_to_de_analysis_expert
            - MUST be appended to tools list!

        workspace_path: Optional workspace path override.
            - Falls back to data_manager.workspace_path
            - Used by LLM factory for local model paths

    Returns:
        Configured ReAct agent with transcriptomics analysis capabilities.
    """

    # =========================================================================
    # 1. INITIALIZE LLM
    # =========================================================================
    settings = get_settings()
    model_params = settings.get_agent_llm_params("transcriptomics_expert")
    llm = create_llm("transcriptomics_expert", model_params, workspace_path=workspace_path)

    # Attach callback handler for streaming
    # WHY: normalize to flat list to prevent double-nesting bug
    if callback_handler and hasattr(llm, "with_config"):
        callbacks = callback_handler if isinstance(callback_handler, list) else [callback_handler]
        llm = llm.with_config(callbacks=callbacks)

    # =========================================================================
    # 2. INITIALIZE SERVICES
    # =========================================================================
    # Services are STATELESS - they process data and return (result, stats, ir)
    # Services stay in core lobster-ai, not in agent packages
    quality_service = QualityService()
    preprocessing_service = PreprocessingService()
    clustering_service = ClusteringService()

    # =========================================================================
    # 3. CREATE TOOLS
    # =========================================================================
    # Shared tools (QC, preprocessing) available to all transcriptomics agents
    shared_tools = create_shared_tools(
        data_manager, quality_service, preprocessing_service
    )

    # Agent-specific tools defined inline
    @tool
    def cluster_modality(
        modality_name: str,
        resolution: float = None,
        # ... parameters
    ) -> str:
        """Perform single-cell clustering and UMAP visualization."""
        # 1. Validate modality exists
        if modality_name not in data_manager.list_modalities():
            raise ModalityNotFoundError(f"Modality '{modality_name}' not found")

        # 2. Get data
        adata = data_manager.get_modality(modality_name)

        # 3. Call stateless service (returns 3-tuple)
        adata_result, stats, ir = clustering_service.cluster_and_visualize(
            adata=adata,
            resolution=resolution,
            # ... more params
        )

        # 4. Store result with descriptive name
        result_name = f"{modality_name}_clustered"
        data_manager.store_modality(name=result_name, adata=adata_result)

        # 5. Log provenance (IR is MANDATORY!)
        data_manager.log_tool_usage(
            tool_name="cluster_modality",
            parameters={"modality_name": modality_name, "resolution": resolution},
            description=f"Clustered {modality_name}",
            ir=ir,  # IR enables reproducible notebooks
        )

        # 6. Return formatted response
        return f"Successfully clustered '{modality_name}' into {stats['n_clusters']} clusters"

    # =========================================================================
    # 4. COLLECT ALL TOOLS
    # =========================================================================
    clustering_tools = [cluster_modality, find_marker_genes]
    direct_tools = shared_tools + clustering_tools

    # CRITICAL: Add delegation tools for sub-agents!
    # These enable handoff_to_annotation_expert(), handoff_to_de_analysis_expert()
    tools = direct_tools
    if delegation_tools:
        tools = tools + delegation_tools

    # =========================================================================
    # 5. CREATE AND RETURN AGENT
    # =========================================================================
    system_prompt = create_transcriptomics_expert_prompt()

    return create_react_agent(
        model=llm,
        tools=tools,
        prompt=system_prompt,
        name=agent_name,
        state_schema=TranscriptomicsExpertState,
    )

[build-system]
requires = ["setuptools>=61.0", "wheel"]
build-backend = "setuptools.build_meta"

[project]
name = "lobster-transcriptomics"
version = "1.0.0"
description = "Transcriptomics agents for Lobster AI - single-cell and bulk RNA-seq analysis"
readme = "README.md"
license = {text = "MIT"}
authors = [
    {name = "Kevin Yar", email = "kevin@omics-os.com"}
]
keywords = [
    "bioinformatics",
    "single-cell",
    "RNA-seq",
    "transcriptomics",
]
classifiers = [
    "Development Status :: 5 - Production/Stable",
    "Intended Audience :: Science/Research",
    "License :: OSI Approved :: MIT License",
    "Operating System :: OS Independent",
    "Programming Language :: Python :: 3.11",
    "Programming Language :: Python :: 3.12",
    "Programming Language :: Python :: 3.13",
    "Programming Language :: Python :: 3.14",
    "Topic :: Scientific/Engineering :: Bio-Informatics",
]
requires-python = ">=3.11"
dependencies = [
    # Compatible release constraint - allows 1.0.x patches
    "lobster-ai~=1.0.0",
    # Domain-specific dependencies
    "scanpy",
    "leidenalg",
]

[project.urls]
Homepage = "https://omics-os.com"
Documentation = "https://docs.omics-os.com"
Repository = "https://github.com/the-omics-os/lobster-ai"

# =============================================================================
# ENTRY POINTS (Critical for discovery!)
# =============================================================================
# Format: agent_name = "module.path:AGENT_CONFIG"
# ComponentRegistry scans these to find all available agents
[project.entry-points."lobster.agents"]
transcriptomics_expert = "lobster.agents.transcriptomics.transcriptomics_expert:AGENT_CONFIG"
annotation_expert = "lobster.agents.transcriptomics.annotation_expert:AGENT_CONFIG"
de_analysis_expert = "lobster.agents.transcriptomics.de_analysis_expert:AGENT_CONFIG"

# State classes for graph builder
[project.entry-points."lobster.states"]
TranscriptomicsExpertState = "lobster.agents.transcriptomics.state:TranscriptomicsExpertState"
AnnotationExpertState = "lobster.agents.transcriptomics.state:AnnotationExpertState"
DEAnalysisExpertState = "lobster.agents.transcriptomics.state:DEAnalysisExpertState"

# =============================================================================
# SETUPTOOLS (Critical for PEP 420!)
# =============================================================================
[tool.setuptools]
# namespaces = true enables PEP 420 namespace packages
# This allows lobster-ai and lobster-transcriptomics to merge into one namespace
packages.find = {where = ["."], include = ["lobster*"], namespaces = true}

[tool.setuptools.package-data]
"*" = ["py.typed"]

# In your service (lobster.services.{domain})
def analyze(self, adata, **params) -> Tuple[AnnData, Dict, AnalysisStep]:
    """
    Perform analysis on data.

    Returns:
        result: Processed AnnData object
        stats: Dictionary of statistics for user display
        ir: AnalysisStep for provenance (enables notebook export)
    """
    # ... processing logic ...
    return processed_adata, stats_dict, analysis_step_ir

@tool
def analyze_modality(modality_name: str, **params) -> str:
    """
    Analyze the specified data modality.

    Args:
        modality_name: Name of the data modality to analyze
        **params: Analysis parameters
    """
    # 1. VALIDATE: Check modality exists
    if modality_name not in data_manager.list_modalities():
        raise ModalityNotFoundError(f"Modality '{modality_name}' not found")

    # 2. GET DATA
    adata = data_manager.get_modality(modality_name)

    # 3. CALL SERVICE (returns 3-tuple)
    result, stats, ir = service.analyze(adata, **params)

    # 4. STORE RESULT (with descriptive naming)
    new_name = f"{modality_name}_analyzed"
    data_manager.store_modality(name=new_name, adata=result)

    # 5. LOG PROVENANCE (IR is mandatory!)
    data_manager.log_tool_usage(
        tool_name="analyze_modality",
        parameters={"modality_name": modality_name, **params},
        description=f"Analyzed {modality_name}",
        ir=ir,  # This enables reproducible notebook export!
    )

    # 6. RETURN USER-FRIENDLY RESPONSE
    return f"Analysis complete: {stats['key_metric']}"

# Check if entry points are registered
pip show lobster-my-domain

# Should show entry_points section
# Verify entry point format is correct

# Run contract tests to identify issues
pytest tests/test_contract.py -v

# Common issues:
# - Missing data_manager parameter
# - Using handoff_tools instead of delegation_tools
# - Missing workspace_path parameter

# Check factory function path is correct
from lobster.agents.my_domain.my_agent import AGENT_CONFIG
print(AGENT_CONFIG.factory_function)

# Try importing the factory directly
from lobster.agents.my_domain.my_agent import my_agent

# Verify child_agents is set in AGENT_CONFIG
print(AGENT_CONFIG.child_agents)

# Verify delegation_tools is appended in factory
# Look for: if delegation_tools: tools = tools + delegation_tools