model_executor/models/deepseek_v2.py: the DeepSeek wrapper

    def _send_and_receive(
        self,
        hidden_states: torch.Tensor,
        **send_kwargs: torch.Tensor,
    ) -> torch.Tensor:
        afd_metadata = get_afd_metadata_from_forward_context()
        if afd_metadata is None:
            raise RuntimeError("RemoteFFNProxy requires AFD forward metadata")
        forward_context = get_forward_context()
        stage_idx = int(
            getattr(forward_context, "ubatch_idx", afd_metadata.stage_idx),
        )
        afd_metadata.stage_idx = stage_idx
        metadata = AFDTransferMetadata.create_attention_metadata(
            layer_idx=self.layer_idx,
            stage_idx=stage_idx,
            seq_len=int(hidden_states.shape[0]),
        )
        context = AFDTransferContext(metadata=metadata)
        afd_metadata.connector.send_attn_output(
            hidden_states,
            context,
            **send_kwargs,
        )
        hidden_states = maybe_apply_dbo_yield(
            hidden_states,
            role="attention",
        )
        return afd_metadata.connector.recv_ffn_output(
            ref_tensor=hidden_states,
            ubatch_idx=stage_idx,
        )

    def compute_experts_output(
        self,
        hidden_states: torch.Tensor,
        router_logits: torch.Tensor,
    ) -> torch.Tensor:
        """Execute the native external-router runner on the FFN role."""
        if not self.compute_gate_on_attention or not self.is_moe_layer:
            raise RuntimeError(
                "compute_experts_output requires an Attention-side-gate MoE layer",
            )
        if not isinstance(self.mlp, native.DeepseekV2MoE):
            raise RuntimeError("FFN role does not own a native DeepSeek MoE")
        # v0.30 runner contract: gate is None means the runner consumes the
        # router logits transported from Attention (external routing).
        if self.mlp.experts.gate is not None:
            raise RuntimeError("FFN native runner must use external routing")
        return self.mlp.experts(
            hidden_states=hidden_states,
            router_logits=router_logits,
        )

    def get_experts_layer_indices(self) -> tuple[int, ...]:
        # Async NPU FFN and CUDA remote-expert execution share this inventory.
        # uses_remote_experts selects a CUDA-specific construction path; it
        # does not describe whether an NPU decoder contains routed experts.
        return tuple(
            layer_idx
            for layer_idx, layer in enumerate(self.layers)
            if isinstance(layer, AFDDeepseekV2DecoderLayer) and layer.is_moe_layer
        )

    def get_experts_routing_spec(
        self,
        layer_idx: int,
    ) -> AFDExpertRoutingSpec:
        """Return the static native-router contract for graph capture."""
        layer = self.layers[layer_idx]
        gate = layer.mlp.gate
        return AFDExpertRoutingSpec(
            router_logits_width=int(layer.mlp.n_routed_experts),
            router_logits_dtype=gate.out_dtype or gate.weight.dtype,
        )