Method from_dict

entity/configs/node/tooling.py:197–274

(cls, data: Mapping[str, Any], *, path: str)

    @classmethod
    def from_dict(cls, data: Mapping[str, Any], *, path: str) -> "FunctionToolConfig":
        mapping = require_mapping(data, path)
        tools = ensure_list(mapping.get("tools"))
        if not tools:
            raise ConfigError("tools must be provided for function tooling", extend_path(path, "tools"))

        catalog = get_function_catalog()
        expanded_tools: List[Tuple[Dict[str, Any], str]] = []
        for idx, tool in enumerate(tools):
            tool_path = extend_path(path, f"tools[{idx}]")
            if not isinstance(tool, Mapping):
                raise ConfigError("tool entry must be a mapping", tool_path)
            normalized = dict(tool)
            raw_name = normalized.get("name")
            if not isinstance(raw_name, str) or not raw_name.strip():
                raise ConfigError("tool name is required", extend_path(tool_path, "name"))
            name = raw_name.strip()
            normalized["name"] = name
            module_name = cls._extract_module_from_all(name)
            if module_name:
                expanded_tools.extend(
                    cls._expand_module_all_entry(
                        module_name=module_name,
                        catalog=catalog,
                        path=tool_path,
                        original=normalized,
                    )
                )
                continue
            expanded_tools.append((normalized, tool_path))

        tool_specs: List[Dict[str, Any]] = []
        seen_functions: Dict[str, str] = {}
        for entry, entry_path in expanded_tools:
            normalized = dict(entry)
            name = normalized.get("name")
            if not isinstance(name, str) or not name.strip():
                raise ConfigError("tool name is required", extend_path(entry_path, "name"))
            metadata = catalog.get(name)
            if metadata is None:
                raise ConfigError(
                    f"function '{name}' not found under function directory",
                    extend_path(entry_path, "name"),
                )
            previous = seen_functions.get(name)
            if previous is not None:
                raise ConfigError(
                    f"function '{name}' is declared multiple times (also in {previous})",
                    extend_path(entry_path, "name"),
                )
            seen_functions[name] = entry_path

            auto_fill = normalized.get("auto_fill", True)
            if not isinstance(auto_fill, bool):
                raise ConfigError("auto_fill must be boolean", extend_path(entry_path, "auto_fill"))
            merged = dict(normalized)
            if auto_fill:
                if not merged.get("description") and metadata.description: