Method build

masfactory/components/composed_graph/hub_graph.py:113–214

Build the hub-spoke topology with handoff routing.

(self)

    @masf_hook(Node.Hook.BUILD)
    def build(self):
        """Build the hub-spoke topology with handoff routing."""
        if self._is_built:
            return

        # Build routing conditions
        routes: dict[str, Callable] = {}
        
        # Hub: route when no handoff pending
        def route_to_hub(message: dict, attributes: dict) -> bool:
            handoff = attributes.get("_handoff_to")
            return handoff is None or handoff == "" or handoff not in self._spoke_names_set
        routes[self._hub_name] = route_to_hub
        
        # Spokes: route when handoff matches
        for spoke_name in self._spoke_names:
            def make_spoke_condition(target: str) -> Callable:
                def condition(message: dict, attributes: dict) -> bool:
                    return attributes.get("_handoff_to") == target
                return condition
            routes[spoke_name] = make_spoke_condition(spoke_name)

        # Create router
        router = self.create_node(
            LogicSwitch,
            name=f"{self.name}_router",
            routes=routes,
        )
        
        # Clear handoff after dispatch
        def clear_handoff(_node: Node, _result: object, _message: dict) -> None:
            self._attributes_store["_handoff_to"] = None
        router.hooks.register(Node.Hook.MESSAGE_DISPATCH_OUT.AFTER, clear_handoff)

        # Create handoff tools
        handoff_tools = [self._create_handoff_tool(sn) for sn in self._spoke_names]

        # Create hub agent
        hub_existing_instructions = self._hub_template.prototype_config.get("instructions", "")
        hub_combined_instructions = (
            f"{self._graph_instructions}\n{hub_existing_instructions}".strip()
            if self._graph_instructions else hub_existing_instructions
        )
        hub_existing_tools = list(self._hub_template.prototype_config.get("tools", []))
        
        hub_agent = self.create_node(
            self._hub_template.node_cls,
            name=self._hub_name,
            **{
                **self._hub_template.render_config(),
                "instructions": hub_combined_instructions,
                "memories": [self._shared_memory],
                "model": self._model,
                "tools": hub_existing_tools + handoff_tools,
            },
        )
        
        # Track hub output