Method compute

src/harness/tools/filtering.py:44–144

Compute effective tool configuration for a step. Applies filtering rules to determine which tools and submodules are available for the current step: - If both plan and step specify enabled tools, uses intersection - If only one specifies, uses that list - If

(
        cls,
        all_tools: List[Dict[str, Any]],
        context: Dict[str, Any],
        step_config: Optional[Dict[str, Any]] = None,
    )

    @classmethod
    def compute(
        cls,
        all_tools: List[Dict[str, Any]],
        context: Dict[str, Any],
        step_config: Optional[Dict[str, Any]] = None,
    ) -> EffectiveToolConfig:
        """Compute effective tool configuration for a step.

        Applies filtering rules to determine which tools and submodules
        are available for the current step:
        - If both plan and step specify enabled tools, uses intersection
        - If only one specifies, uses that list
        - If neither specifies, all tools are available

        Args:
            all_tools: Complete list of available tool definitions.
            context: Workflow context containing plan-level settings.
            step_config: Optional step-specific configuration.

        Returns:
            EffectiveToolConfig with filtered tools and submodules.
        """

        def normalize_enabled_list(value: Any) -> Optional[List[str]]:
            if value is None:
                return None
            if isinstance(value, (list, tuple, set)):
                return [str(v) for v in value]
            return [str(value)]

        def compute_effective_set(
            plan_key: str,
            step_key: str,
        ) -> Optional[Set[str]]:
            """Compute effective enabled set from plan and step configs."""
            plan_enabled = normalize_enabled_list(context.get(plan_key))
            step_enabled = (
                normalize_enabled_list(step_config.get(step_key))
                if step_config
                else None
            )

            if plan_enabled is not None and step_enabled is not None:
                return set(plan_enabled) & set(step_enabled)
            elif step_enabled is not None:
                return set(step_enabled)
            elif plan_enabled is not None:
                return set(plan_enabled)
            return None

        # Compute effective tools
        tools_enabled = compute_effective_set(
            ContextKeys.ENABLED_TOOLS, ContextKeys.ENABLED_TOOLS
        )
        if tools_enabled is None:
            effective_tools = all_tools
        else:
            effective_tools = [